Upload De Arquivo Com Xupload

Olá Pessoal

Estou utilizando para fazer upload esta extensao http://www.yiiframework.com/extension/xupload/, so que estou com um pequeno problema.

Eu gostaria de chamar uma função quando a lista de upload desse por completa, alguem saberia como fazer isso:


$this->widget('backend.extensions.xupload.XUpload', array(

                        'url' => '/sisadm/obra/upload',

                        'model' => $upload,

                        'attribute' => 'file',

                        'multiple' => true,

                        

                        'options' => array(

                               'sequentialUploads'=>true,

                               'acceptFileTypes' => "js:/(\.|\/)(jpe?g|png|jpg|gif)$/i",                          

                               'maxFileSize' =>  2000000000, // 20MB

                               'previewMaxWidth' => 100,

                               'done' => 'js:function(e, data) {

                                         

                                           $("a[href=#tab-fotos]").tab("show");  

                                           console.log("teete");

                                            

                                }',

                              

                                'progressall'=>"js:function (e, data) {

                                    var progress = parseInt(data.loaded / data.total * 100, 10);

                                    $('#progress .bar').css(

                                        'width',

                                        progress + '%'

                                    );

                                   

                                }",

                               

                        )


    ));

ja tentei e mesmo assim não da certo. Toda vez que ele completa o envio de um arquivo ele ja chama a função.

Edson,

Se for usar só a callback ‘done’ não funciona?

Olá Newerton blz

Então eu consegui resolver isso com o stop:

Agora eu estou com outro problema, tipo como pode ver o XUpload utiliza o CUploadedFile para salvar os arquivos. Mas o caso é teria como reduzir o tamanho da imagem no processo de envio?

Pois como pode ver eu reduzo a imagem apos o salvamento no servidor ai eu pego o path da imagem e reduzo mais este processo creio eu que reduz o desempenho do envio.

Pois ele joga a imagem de 4mb e depois deste envio ele reduz será que teria como melhorar este processo.




protected function handleUploading()

    {

        $this->init();

        $model = $this->formModel;

        $model->{$this->fileAttribute} = CUploadedFile::getInstance($model, $this->fileAttribute);

        if ($model->{$this->fileAttribute} !== null) {

            

            $model->{$this->mimeTypeAttribute} = $model->{$this->fileAttribute}->getType();

            $model->{$this->sizeAttribute} = $model->{$this->fileAttribute}->getSize();

            $model->{$this->displayNameAttribute} = $model->{$this->fileAttribute}->getName();

            $model->{$this->fileNameAttribute} = substr(md5(uniqid(time())), 0, 30).'.'.$model->{$this->fileAttribute}->getExtensionName();


            if ($model->validate()) {


                $path = $this->getPath();

               


                if (!is_dir($path)) {

                    mkdir($path, 0777, true);

                    chmod($path, 0777);

                }


                try {

                    $model->{$this->fileAttribute}->saveAs($path . $model->{$this->fileNameAttribute});

                    chmod($path . $model->{$this->fileNameAttribute}, 0777);


//Redução da imagem gerando a maior ex 800x600 e a thumbs ex 200x100


                    $image = Yii::app()->image->load($path . $model->{$this->fileNameAttribute});

                    $image->resize($this->gWidth,$this->gHeight,Image::AUTO);

                    $image->save(NULL,80);


                    if($this->thumbs){

                         $image = Yii::app()->image->load($path . $model->{$this->fileNameAttribute});

                         $image->resize($this->tWidth,$this->tHeight,Image::AUTO);

                         $image->save($this->pathThumbs . $model->{$this->fileNameAttribute},100);

                    }

                   

                    $rec = new $this->nomeModel;

                    $rec->{$this->fieldRelacionamento} = Yii::app()->user->getState('IdRegistro');

                    $rec->iduser = Yii::app()->user->id;

                    $rec->{$this->fieldCaminho} = $model->{$this->fileNameAttribute};

                    $rec->save();

                    

                  

                    

                } catch (Exception $e) {

                    

                    $fileG = $this->path .'/'. $model->{$this->fileNameAttribute};

                    $fileT = $this->pathThumbs . $model->{$this->fileNameAttribute};

                    if(is_file($fileG)){

                         unlink($fileG);

                    }

                    if(is_file($fileT)){

                          unlink($fileT);

                     }

                    

                      throw new CHttpException(500, "Não foi possível fazer upload de arquivos");

                }


                

              


                $returnValue = $this->beforeReturn();

                if ($returnValue === true) {

                    echo json_encode(array(array(

                        "name" => $model->{$this->displayNameAttribute},

                        "type" => $model->{$this->mimeTypeAttribute},

                        "size" => $model->{$this->sizeAttribute},

                        "url" => $this->getFileUrl($model->{$this->fileNameAttribute}),

                        "thumbnail_url" => $model->getThumbnailUrl($this->getPublicPath()),

                        "delete_url" => $this->getController()->createUrl($this->getId(), array(

                            "_method" => "delete",

                            "file" => $model->{$this->fileNameAttribute},

                        )),

                        "delete_type" => "POST"

                    )));

                } else {

                    echo json_encode(array(array("error" => $returnValue,)));

                    Yii::log("XUploadAction: " . $returnValue, CLogger::LEVEL_ERROR, "xupload.actions.XUploadAction");

                }

            } else {

                echo json_encode(array(array("error" => $model->getErrors($this->fileAttribute),)));

                Yii::log("XUploadAction: " . CVarDumper::dumpAsString($model->getErrors()), CLogger::LEVEL_ERROR, "xupload.actions.XUploadAction");

            }

        } else {

            throw new CHttpException(500, "Não foi possível fazer upload de arquivos");

        }

    }

No codigo acima passo os tamanhos por parametros.

Valews

Edson,

Para eu uso essa extensão aqui:

http://www.yiiframework.com/extension/upload

Ela faz quase tudo.

Ref.: http://www.verot.net/php_class_upload_samples.htm

Se quiser o código de como eu uso, eu posto aqui.

O meu recebe um array() de $_FILES, que é gerado uma imagem grande e uma miniatura, com várias configurações.

Legal Newerton

Posta ai…

Agradeço desde já.

Edson,

Faça um for() com a quantidade de campos de imagens que deseja usar, não importa se vai usar 1 ou 10, essa função que fiz irá funcionar.

Parametros que uso no Controller (Create/Update).




if($model->validate()) {

	if($model->save()) {


		////////////////////////////////////////////////////////////////////////////////////

		//UPLOAD DAS IMAGENS

		////////////////////////////////////////////////////////////////////////////////////


		if (!empty($_FILES['img']['name'][0])) {


			$options = array(

				'resize-grande' => false, //redimensionar imagem grande

				'resize-pequeno' => true, //redimensionar imagem pequena


				'ratio-grande' => array('largura' => false, 'altura' => false), //ratio da imagem grande

				'ratio-pequeno' => array('largura' => true, 'altura' => false), //ratio da imagem pequena


				'medida-grande' => array('largura' => false, 'altura' => false), //medida da imagem grande

				'medida-pequeno' => array('largura' => 243, 'altura' => false), //medida da imagem pequena


				'extensao-grande' => 'jpg', //extensao da imagem grande

				'extensao-pequeno' => 'gif', //extensao da imagem pequena


				'cortar-grande' => false, //cortar imagem grande

				'cortar-pequeno' => false, //cortar imagem pequena

				'cortar-parametro' => 'LT', // T=top, R=right, B=bottom, L=left

				'thumbnails' => true, //gerar miniatura


				'watermark' => false, //adicionar marca dagua

				'watermark-imagem' => 'watermark.png', //nome da imagem

				'watermark-x' => '50%', //posicao horizontal

				'watermark-y' => '50%', //posicao vertical

				'watermark-thumbnails' => false, //adicionar marca daqua nas miniaturas


				'pasta' => false, //usar pasta diferente

				'pasta_image' => Yii::getPathOfAlias('webroot') . "/up/imgs/images/", //pasta da imagem grande

				'pasta_thumb' => Yii::getPathOfAlias('webroot') . "/up/imgs/thumbs/", //pasta da imagem pequena


				'save' => true, //salvar no banco de dados

				'name' => '' //nome da imagem adicionado no campo de legenda

			);


			Helpers::UploadImage($_FILES['img'], $model, $options);

		}

	}

}



Agora a função que eu criei na class components/Helpers.php




public static function UploadImage($file, $model, $options = array()) {


        Yii::import('application.extensions.upload.Upload');


        if (!is_array($options)) {

            throw new CHttpException(400, 'As opções de envio de arquivo precisa ser um array.');

        }


        $imgs = array();

        foreach ($file as $k => $l) {

            if (is_array($l)) {

                foreach ($l as $i => $v) {

                    if (!array_key_exists($i, $imgs))

                        $imgs[$i] = array();

                    $imgs[$i][$k] = $v;

                }

            } else {

                $imgs[0][$k] = $l;

            }

        }


        foreach ($imgs as $img) {

            set_time_limit(0);


            $imagem = new Upload($img, Yii::app()->language);


            if ($imagem->uploaded) {


		///////////////////////////////////////////////////////////////

		// Faz parte do meu Model onde eu só salvo as imagens/arquivos

		///////////////////////////////////////////////////////////////

                $file = new Arquivo();

                $file->tipo = 'imagem';

		$file->datacriacao = date('Y-m-d');

		///////////////////////////////////////////////////////////////

		///////////////////////////////////////////////////////////////

				

                $imagem->allowed = array('image/*'); //Permitir somente imagem

                if ($options['save']) {

                    $imagem->file_new_name_body = time(); //Nome do arquivo

                    $imagem->file_name_body_add = "_" . $file->primaryKey; // Préfixo adicional (opcional)

                } else {

                    $imagem->file_new_name_body = $options['name']; //Definir o nome manual

                }


                $imagem->image_resize = $options['resize-grande']; //Alterar tamanho da imagem


                if ($options['medida-grande']['largura']) {

                    $imagem->image_x = $options['medida-grande']['largura']; //Medida da largura da imagem

                }


                if ($options['medida-grande']['altura']) {

                    $imagem->image_y = $options['medida-grande']['altura']; //Medida da altura da imagem

                }


                if ($options['cortar-grande']) {

                    $imagem->image_ratio_crop = $options['cortar-parametro']; //Medida do recorte da imagem

                } else {

                    $imagem->image_ratio_x = $options['ratio-grande']['altura']; //Setar a relação da imagem na altura

                    $imagem->image_ratio_y = $options['ratio-grande']['largura']; //Setar a relação da iamgem na largura

                }


                if ($options['extensao-grande']) {

                    $imagem->image_convert = $options['extensao-grande']; //Nova extensão da imagem grande

                }


				

                if ($options['watermark']) {

                    $imagem->image_watermark = Yii::getPathOfAlias('webroot') . '/images/' . $options['watermark-imagem']; //Caminho da imagem da marca d'água

                    $imagem->image_watermark_x = $options['watermark-x']; //Setar a posição da marca d'água

                    $imagem->image_watermark_y = $options['watermark-y']; //Setar a posição da marca d'água

                }


                if (!$options['pasta'])

                    $pasta = Yii::getPathOfAlias('webroot') . "/up/{$file->datacriacao}/"; //Pasta padrão que irá ser salvo a imagem

                else

                    $pasta = $options['pasta_image']; //Pasta que deseja que a imagem seja salvo (ver na variável $options no Controller)


                $imagem->process($pasta);

                if ($imagem->processed) {

                    $file->arquivo = $imagem->file_dst_name; //Setando na variavel o nome completo do arquivo com o previso, para ser salvo no banco de dados.

                    if ($options['save']) //Se deseja salvar no banco de dado

                        $file->save();

                } else {

                    Yii::app()->user->setFlash('error', $imagem->error);

                    Arquivo::model()->deleteByPk($file->id);

                    unset($file->id);

                }


		///////////////////////////////////////////////////////////////

		///// MINIATURA

		///////////////////////////////////////////////////////////////

				

                if ($options['thumbnails']) {


                    $file->datacriacao = $model->datacriacao;


                    $imagem->allowed = array('image/*');

                    if ($options['save']) {

                        $imagem->file_new_name_body = strtotime($file->datacriacao);

                        $imagem->file_name_body_add = "_" . $file->primaryKey;

                    } else {

                        $imagem->file_new_name_body = $options['name'];

                    }

                    $imagem->image_resize = $options['resize-pequeno'];




                    if (is_numeric($options['medida-pequeno']['largura'])) {

                        $imagem->image_x = $options['medida-pequeno']['largura'];

                    }


                    if (is_numeric($options['medida-pequeno']['altura'])) {

                        $imagem->image_y = $options['medida-pequeno']['altura'];

                    }


                    if ($options['cortar-pequeno']) {

                        $imagem->image_ratio_crop = $options['cortar-parametro'];

                    } else {

                        $imagem->image_ratio_x = $options['ratio-pequeno']['altura'];

                        $imagem->image_ratio_y = $options['ratio-pequeno']['largura'];

                    }


                    if ($options['extensao-pequeno']) {

                        $imagem->image_convert = $options['extensao-pequeno'];

                    }


                    if ($options['watermark-thumbnails']) {

                        if ($options['watermark']) {

                            $imagem->image_watermark = Yii::getPathOfAlias('webroot') . '/images/site/' . $options['watermark-imagem'];

                            $imagem->image_watermark_x = $options['watermark-x'];

                            $imagem->image_watermark_y = $options['watermark-y'];

                        }

                    }


                    if (!$options['pasta'])

                        $pasta = Yii::getPathOfAlias('webroot') . "/up/" . get_class($model) . "/{$datacriacao}/";

                    else

                        $pasta = $options['pasta_thumb'];


                    $imagem->process($pasta);

                    if ($imagem->processed) {

                        $file->mini = $imagem->file_dst_name;

                        if ($options['save'])

                            $file->save();

                    } else {

                        Yii::app()->user->setFlash('error', $imagem->error);

                    }

                }

                $imagem->clean();

            }

        }

    }



Detalhei alguns itens, se observar a função, todas as variáveis nas condicional, vem da variável $options que está no Controller.

Olá Newerton,

Estou tendo dificuldade para popular o array na inclusão e exibir as imagens salvas no banco na alteração.

Poderia postar um exemplo do código destas View’s?

Desde já agradeço!

Leandro,

Os nomes das imagens, estão sendo salva na mesma tabela ou em tabelas diferente?

Posta seu código.

Olá Newerton,

A princípio eu criei um campo na tabela de pessoa para armazenar a foto no tamanho normal e outro para armazená-la no tamanho reduzido, mas nada me impede de ter outra tabela para manter estes dados assim como você fez no seu exemplo.

Na visualização _form eu coloquei o seguinte código para pegar o caminho da imagem:




	<div class="row">

		<?php echo $form->labelEx($model,'ft_pessoa'); ?>

		<?php //echo CHtml::activeFileField($model, "[0]ft_pessoa");?>

		<br/>

		<?php //echo CHtml::activeFileField($model, "[1]ft_pessoa");?>

		<br/>

		<?php echo CHtml::activeFileField($model, "ft_pessoa");?>

	</div>



Implementei o código nas actions create e update do controle e criei o componente Helpers.php conforme o exemplo que você passou, minha dúvida é como você implementa a visualização no _form.

Leandro,

Para trabalhar com 1 imagem para cada item, é mais fácil.

O exemplo que enviei, recebe um array de imagens, que no seu caso não necessita.

Quais são os nomes dos campos que vão receber o nome da imagem grande e pequena?

Dahora Newerton

Vou dar uma analisada…Valews…Sucesso!!!

Olá Newerton,

Os campos são ft_pessoa e ft_pessoa_mini da tabela pessoa.

Obrigado.