carono\yii2file\Uploader

Complexity

Total Complexity

49

Size/Duplication

Total Lines	311
Duplicated Lines	0 %

Importance

Changes

0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	data()	0	4	1
A	folder()	0	4	1
A	name()	0	4	1
A	getFileNameWithOutExtension()	0	3	1
A	process()	0	23	6
A	getUserId()	0	8	2
A	formAliasPath()	0	7	3
A	formUid()	0	7	2
A	formAttributes()	0	15	2
A	context()	0	4	1
A	getUid()	0	3	2
A	getMimeType()	0	3	1
A	copy()	0	8	3
A	processFilePath()	0	14	5
A	slug()	0	4	1
A	delete()	0	4	1
A	renameFile()	0	4	2
A	getFileName()	0	3	2
A	copyFile()	0	4	2
A	getSession()	0	8	3
A	getFileExtension()	0	6	2
A	copyUploadedFile()	0	4	2
A	generateUid()	0	4	1
A	getNewFileAlias()	0	3	1
A	loadAttributes()	0	3	1

<?php

namespace carono\yii2file;

use Yii;
use yii\base\Component;
use yii\base\Security;
use yii\db\ActiveRecord;
use yii\db\Expression;
use yii\helpers\ArrayHelper;
use yii\helpers\FileHelper;
use yii\web\UploadedFile;

/**
 * Class FileUpload
 *
 * @package carono\components
 * @property string $fullName
 */
class Uploader extends Component
{
    /**
     * @var FileUploadTrait
     */
    public $modelClass;
    public $data;
    public $file;
    public $name;
    public $slug;
    public $uid;
    public $delete = true;
    public $folder;
    public $context;
    protected $fileName;
    protected $filePath;

    /**
     * @param $name
     * @return $this
     */
    public function name($name)
    {
        $this->name = $name;
        return $this;
    }

    /**
     * @param $data
     * @return $this
     */
    public function data($data)
    {
        $this->data = $data;
        return $this;
    }

    /**
     * @param $path
     * @return $this
     */
    public function folder($path)
    {
        $this->folder = $path;
        return $this;
    }

    public function context($context)
    {
        $this->context = $context;
        return $this;
    }

    /**
     * @param bool $deleteOnFinish
     * @return $this
     */
    public function delete($deleteOnFinish = true)
    {
        $this->delete = $deleteOnFinish;
        return $this;
    }

    /**
     * @return null|string
     */
    protected function getSession()
    {
        if (isset(Yii::$app->session)) {
            $session = Yii::$app->session->getIsActive() ? Yii::$app->session->getId() : null;

The method getIsActive() does not exist on null.

        } else {
            $session = null;
        }
        return $session;
    }

    /**
     * @return mixed
     */
    public function getFileName()
    {
        return $this->name ?: $this->fileName;
    }

    /**
     * @return string
     */
    protected function getFileNameWithOutExtension()
    {
        return basename($this->getFileName(), '.' . $this->getFileExtension());
    }

    /**
     * @return string
     */
    protected function getMimeType()
    {
        return FileHelper::getMimeType($this->filePath);
    }

    /**
     * @return mixed|string
     */
    protected function getFileExtension()
    {
        if (!$extension = strtolower(pathinfo($this->fileName, PATHINFO_EXTENSION))) {
            $extension = ArrayHelper::getValue(FileHelper::getExtensionsByMimeType($this->getMimeType()), 0);
        }
        return $extension;
    }

    /**
     * @return int|null|string
     */
    public function getUserId()
    {
        if (isset(Yii::$app->user)) {
            $userId = Yii::$app->user->getId();

The method getId() does not exist on null.

        } else {
            $userId = null;
        }
        return $userId;
    }

    /**
     * @param $source
     * @param $destination
     * @throws \Exception
     */
    protected function copyUploadedFile($source, $destination)
    {
        if (!move_uploaded_file($source, $destination)) {
            throw new \Exception('Unknown upload error');
        }
    }

    /**
     * @param $source
     * @param $destination
     * @throws \Exception
     */
    protected function renameFile($source, $destination)
    {
        if (!rename($source, $destination)) {
            throw new \Exception('Failed rename file');
        }
    }

    /**
     * @param $source
     * @param $destination
     * @throws \Exception
     */
    protected function copyFile($source, $destination)
    {
        if (!copy($source, $destination)) {
            throw new \Exception('Failed copy file');
        }
    }

    /**
     * @param $source
     * @param $destination
     * @throws \Exception
     */
    public function copy($source, $destination)
    {
        if (is_uploaded_file($source)) {
            $this->copyUploadedFile($source, $destination);
        } elseif ($this->delete) {
            $this->renameFile($source, $destination);
        } else {
            $this->copyFile($source, $destination);
        }
    }

    /**
     * @return string
     */
    public function getUid()
    {
        return $this->uid = $this->uid ?: $this->formUid();
    }

    /**
     * @return string
     */
    public function getNewFileAlias()
    {
        return static::formAliasPath($this->getUid(), $this->folder);
    }

    /**
     * @param ActiveRecord $model
     * @param $attributes
     */
    public function loadAttributes($model, $attributes)
    {
        $model->setAttributes($attributes);
    }

    public function formAttributes()
    {
        $this->processFilePath($this->file);
        return [
            'session' => $this->getSession(),
            'name' => $this->getFileNameWithOutExtension(),
            'extension' => $this->getFileExtension(),
            'user_id' => $this->getUserId(),
            'uid' => $this->getUid(),
            'data' => !is_null($this->data) ? json_encode($this->data) : null,
            'mime_type' => $this->getMimeType(),
            'md5' => md5_file($this->filePath),
            'folder' => static::formAliasPath($this->getUid(), $this->folder),
            'slug' => $this->slug,
            'size' => filesize($this->filePath)
        ];
    }

    /**
     * @return FileUploadTrait|null
     * @throws \Exception
     */
    public function process()
    {
        /**
         * @var FileUploadTrait $model
         */
        $model = new $this->modelClass();
        $this->loadAttributes($model, $this->formAttributes());

$model of type carono\yii2file\FileUploadTrait is incompatible with the type yii\db\ActiveRecord expected by parameter $model of carono\yii2file\Uploader::loadAttributes().

        $newFilePath = $model->getRealFilePath();
        if (!is_dir($realFolder = dirname($newFilePath))) {
            if (!mkdir($realFolder, 0777, true) && !is_dir($realFolder)) {
                throw new \RuntimeException(sprintf('Directory "%s" was not created', $realFolder));
            }
        }
        if (!file_exists($this->filePath)) {
            throw new \Exception('File not loaded or not exist');
        }
        $this->copy($this->filePath, $newFilePath);
        if ($model->save()) {

It seems like save() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            return $model;
        }

        $model->deleteFile();
        return null;
    }

    /**
     * @param $file
     */
    protected function processFilePath($file)
    {
        if (strpos($file, 'http') === 0) {
            $context = $this->context ? stream_context_create($this->context) : null;
            $tmp = Yii::getAlias('@runtime') . DIRECTORY_SEPARATOR . uniqid('file_upload_', true);
            file_put_contents($tmp, file_get_contents($file, false, $context));
            $this->filePath = $tmp;
            $this->fileName = explode('?', basename($file))[0];
        } elseif (is_string($file)) {
            $this->filePath = Yii::getAlias($file);
            $this->fileName = basename($this->filePath);
        } elseif ($file instanceof UploadedFile) {
            $this->filePath = $file->tempName;
            $this->fileName = $file->name;
        }
    }

    /**
     * @param $slug
     * @return $this
     */
    public function slug($slug)
    {
        $this->slug = $slug;
        return $this;
    }

    /**
     * @return string
     */
    protected function generateUid()
    {
        $sec = new Security();
        return md5($sec->generateRandomString(64));
    }

    /**
     * @return string
     */
    protected function formUid()
    {
        $class = $this->modelClass;
        do {
            $uPath = $this->generateUid();
        } while ($class::find()->where(['uid' => $uPath])->exists());
        return $uPath;
    }

    /**
     * @param $path
     * @param null|string $aliasPrefix
     * @return string
     */
    public static function formAliasPath($path, $aliasPrefix = null)
    {
        $p = $aliasPrefix ? [$aliasPrefix] : [];
        for ($i = 0; $i < 3; $i++) {
            $p[] = $path[$i];
        }
        return implode('/', $p);
    }
}