rkit\filemanager\behaviors\FileBehavior

Complexity

Total Complexity

67

Size/Duplication

Total Lines	447
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	6	1
A	events()	0	10	1
A	beforeSave()	0	10	4
D	afterSave()	0	25	10
A	beforeDelete()	0	6	2
A	deleteFiles()	0	12	3
C	bindFiles()	0	79	11
A	saveFilePathInAttribute()	0	12	4
A	saveFileIdInAttribute()	0	10	4
A	generateThumb()	0	16	4
A	getFileOption()	0	4	1
A	getFileStorage()	0	8	2
B	getTemplatePath()	0	12	5
A	getFilePath()	0	5	1
A	getFileUrl()	0	5	1
A	getFiles()	0	5	1
A	getFile()	0	5	1
A	getFileRules()	0	9	3
A	getFilePresetAfterUpload()	0	11	4
A	getFileRulesDescription()	0	4	1
A	generateThumbName()	0	5	1
A	thumb()	0	5	1
A	thumbFullPath()	0	7	1

<?php

/**
 * @link https://github.com/rkit/filemanager-yii2
 * @copyright Copyright (c) 2015 Igor Romanov
 * @license [MIT](http://opensource.org/licenses/MIT)
 */

namespace rkit\filemanager\behaviors;

use Yii;
use yii\base\Behavior;
use yii\db\ActiveRecord;
use yii\db\Query;
use yii\helpers\ArrayHelper;
use yii\base\InvalidParamException;
use rkit\filemanager\helpers\FormatValidation;

class FileBehavior extends Behavior
{
    /**
     * @var array
     */
    public $attributes = [];

    /**
     * @internal
     */
    public function init()
    {
        parent::init();

        Yii::$app->fileManager->registerTranslations();
    }

    /**
     * @inheritdoc
     * @internal
     */
    public function events()
    {
        return [
            ActiveRecord::EVENT_AFTER_INSERT  => 'afterSave',
            ActiveRecord::EVENT_AFTER_UPDATE  => 'afterSave',
            ActiveRecord::EVENT_BEFORE_INSERT => 'beforeSave',
            ActiveRecord::EVENT_BEFORE_UPDATE => 'beforeSave',
            ActiveRecord::EVENT_BEFORE_DELETE => 'beforeDelete',
        ];
    }

    /**
     * @internal
     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
     * @SuppressWarnings(PHPMD.UnusedLocalVariable)
     */
    public function beforeSave($insert)
    {
        foreach ($this->attributes as $attribute => $options) {
            $oldValue = $this->owner->isNewRecord ? null : $this->owner->getOldAttribute($attribute);
            $isAttributeChanged = $oldValue === null ? true : $this->owner->isAttributeChanged($attribute);

            $this->attributes[$attribute]['isAttributeChanged'] = $isAttributeChanged;
            $this->attributes[$attribute]['oldValue'] = $oldValue;
        }
    }

    /**
     * @internal
     */
    public function afterSave()
    {
        foreach ($this->attributes as $attribute => $options) {
            $files = $this->owner->{$attribute};
            $files = is_numeric($files) && $files ? [$files] : $files;

            $isAttributeNotChanged = $options['isAttributeChanged'] === false || $files === null;
            if ($isAttributeNotChanged) {
                continue;
            }

            if ($files === [] || $files === '') {
                $this->deleteFiles($attribute);

The call to deleteFiles() misses a required argument $files.

                continue;
            }

            $files = $this->bindFiles($attribute, $files);

            if ($this->getFileOption($attribute, 'saveFilePathInAttribute')) {
                $this->saveFilePathInAttribute($attribute, array_shift($files), $options['oldValue']);
            } elseif ($this->getFileOption($attribute, 'saveFileIdInAttribute')) {
                $this->saveFileIdInAttribute($attribute, array_shift($files), $options['oldValue']);
            }
        }
    }

    /**
     * @internal
     * @SuppressWarnings(PHPMD.UnusedLocalVariable)
     */
    public function beforeDelete()
    {
        foreach ($this->attributes as $attribute => $options) {
            $this->deleteFiles($attribute, $this->owner->files);
        }
    }

    /**
     * Delete current files
     *
     * @param Storage $storage

There is no parameter named $storage. Was it maybe removed?

     * @param rkit\filemanager\models\File[] $exceptFiles

There is no parameter named $exceptFiles. Was it maybe removed?

     */
    private function deleteFiles($attribute, $files)
    {
        $storage = $this->getFileStorage($attribute);
        $realPath = $this->getFileOption($attribute, 'basePath');
        $templatePath = $this->getFileOption($attribute, 'templatePath');

        foreach ($files as $file) {
            if ($file->delete()) {
                $storage->deleteDir($realPath . $templatePath($file));
            }
        }
    }

    private function bindFiles($attribute, $files)
    {
        $relation = $this->owner->getRelation('files');
        $linkTable = $relation->via->from[0];
        $fileModel = $relation->modelClass;

        // link field of model in link table
        $viaField = key($relation->via->link);
        // link field of file in link table
        $linkField = current($relation->link);
        // primary key of file table
        $linkPrimaryField = key($relation->link);

        $ownerId = $this->owner->getPrimaryKey();
        $extraFields = $this->getFileOption($attribute, 'extraFields');
        $onUpdateFile = $this->getFileOption($attribute, 'onUpdateFile');

        $newFiles = ArrayHelper::index($fileModel::findAll($files), $linkPrimaryField);
        $newLinks = Yii::$app->session->get(Yii::$app->fileManager->sessionName);

        $currentFiles = ArrayHelper::index($this->getFiles($attribute), $linkPrimaryField);
        $currentFilesIds = ArrayHelper::getColumn($currentFiles, $linkPrimaryField);
        $currentLinks = (new Query())
            ->select('*')
            ->from($linkTable)
            ->where([$viaField => $ownerId, $linkField => $currentFilesIds])
            ->all();

        $resultFiles = [];

        $insertRows = [];
        foreach ($newLinks as $attribute => $items) {
            foreach ($items as $fileId) {
                if (isset($newFiles[$fileId])) {
                    $file = $newFiles[$fileId];
                    $link = [$viaField => $ownerId, $linkField => $fileId];
                    $extra = $extraFields($this->owner, $attribute, $file, $link);
                    $insertRows[] = array_merge([$ownerId, $fileId], array_values($extra));
                    $resultFiles[$file->getPrimaryKey()] = $file;
                }
            }
        }

        $updateRows = [];
        foreach ($currentLinks as $link) {
            if (isset($newFiles[$link[$linkField]])) {
                $file = $newFiles[$link[$linkField]];
                $updateRows[$file->getPrimaryKey()] = $extraFields($this->owner, $attribute, $file, $link);
                $resultFiles[$file->getPrimaryKey()] = $file;
            }
        }

        $this->deleteFiles($attribute, array_diff_key($newFiles, $resultFiles));

        if (count($insertRows)) {
            $columns = [$viaField, $linkField];
            $columns = array_merge($columns, array_keys($extra));

The variable $extra does not seem to be defined for all execution paths leading up to this point.

            Yii::$app->getDb()->createCommand()
                ->batchInsert($linkTable, $columns, $insertRows)
                ->execute();
        }

        if (count($updateRows)) {
            foreach ($updateRows as $fileId => $row) {
                Yii::$app->getDb()->createCommand()
                    ->update($linkTable, $row, [$viaField => $ownerId, $linkField => $fileId])
                    ->execute();
            }
        }

        if ($onUpdateFile) {
            foreach ($resultFiles as $file) {
                $onUpdateFile($file);
            }
        }

        return $resultFiles;
    }

    /**
     * Get the path of the file
     *
     * @param mixed $file
     * @param mixed $oldValue

There is no parameter named $oldValue. Was it maybe removed?

     * @return string
     */
    private function saveFilePathInAttribute($attribute, $file, $defaultValue)
    {
        if (is_object($file)) {
            $templatePath = $this->getFileOption($attribute, 'templatePath');
            $path = $templatePath($file);
            $this->owner->{$attribute} = $path;
            $this->owner->updateAttributes([$attribute => $path]);
        } elseif ($file === false && $defaultValue !== null) {
            return $defaultValue;
        }
        return '';
    }

    /**
     * Get the path of the file
     *
     * @param mixed $file
     * @param mixed $oldValue

There is no parameter named $oldValue. Was it maybe removed?

     * @return string
     */
    private function saveFileIdInAttribute($attribute, $file, $defaultValue)
    {
        if (is_object($file)) {
            $this->owner->{$attribute} = $file->getPrimaryKey();
            $this->owner->updateAttributes([$attribute => $file->getPrimaryKey()]);
        } elseif ($file === false && $defaultValue !== null) {
            return $defaultValue;
        }
        return '';
    }

    /**
     * Generate a thumb
     *
     * @param string $attribute Attribute name of the model
     * @param string $preset The name of the preset
     * @param string $path File path
     * @return string
     */
    private function generateThumb($attribute, $preset, $path)
    {
        $realPath = $this->getFileOption($attribute, 'basePath');
        $thumbPath = $this->generateThumbName($path, $preset);

        if (!file_exists($realPath . $thumbPath)) {
            if (file_exists($realPath . $path)) {
                $thumbInit = ArrayHelper::getValue($this->attributes[$attribute]['preset'], $preset);
                if ($thumbInit) {
                    $thumbInit($realPath, $path, $thumbPath);
                }
            }
        }

        return $thumbPath;
    }

    /**
     * Get file option
     *
     * @param string $attribute Attribute name of the model
     * @param string $option Option name
     * @param mixed $defaultValue Default value
     * @return mixed
     */
    public function getFileOption($attribute, $option, $defaultValue = null)
    {
        return ArrayHelper::getValue($this->attributes[$attribute], $option, $defaultValue);
    }

    /**
     * Get the storage of the file
     *
     * @param string $attribute Attribute name of the model
     * @return Storage
     * @throws InvalidParamException
     */
    public function getFileStorage($attribute)
    {
        $storage = $this->getFileOption($attribute, 'storage');
        if ($storage) {
            return new $storage();
        }
        throw new InvalidParamException('The storage is not defined'); // @codeCoverageIgnore
    }

    /**
     * Get file path
     *
     * @param string $attribute Attribute name of the model
     * @return string
     */
    public function getTemplatePath($attribute, $file = null)
    {
        $needFile = empty($this->owner->{$attribute}) || is_numeric($this->owner->{$attribute});
        if ($needFile && $file === null) {
            $file = $this->getFile($attribute);
        }
        if ($file !== null) {
            $templatePath = $this->getFileOption($attribute, 'templatePath');
            return $templatePath($file);
        }
        return $this->owner->{$attribute};
    }

    /**
     * Get file path
     *
     * @param string $attribute Attribute name of the model
     * @return string
     */
    public function getFilePath($attribute, $file = null)
    {
        $path = $this->getTemplatePath($attribute, $file);
        return $this->getFileOption($attribute, 'basePath') . $path;
    }

    /**
     * Get file url
     *
     * @param string $attribute Attribute name of the model
     * @return string
     */
    public function getFileUrl($attribute, $file = null)
    {
        $path = $this->getTemplatePath($attribute, $file);
        return $this->getFileOption($attribute, 'baseUrl') . $path;
    }

    /**
     * Get files
     *
     * @param string $attribute Attribute name of the model
     * @return array
     */
    public function getFiles($attribute)
    {
        $relationQuery = $this->getFileOption($attribute, 'relationQuery');
        return $this->owner->getFiles($relationQuery)->all();
    }

    /**
     * Get the file
     *
     * @param string $attribute Attribute name of the model
     * @return File|null
     */
    public function getFile($attribute)
    {
        $relationQuery = $this->getFileOption($attribute, 'relationQuery');
        return $this->owner->getFiles($relationQuery)->one();
    }

    /**
     * Get rules
     *
     * @param string $attribute Attribute name of the model
     * @param bool $onlyCoreValidators Only core validators
     * @return array
     */
    public function getFileRules($attribute, $onlyCoreValidators = false)
    {
        $rules = $this->getFileOption($attribute, 'rules', []);
        if ($onlyCoreValidators && isset($rules['imageSize'])) {
            $rules = array_merge($rules, $rules['imageSize']);
            unset($rules['imageSize']);
        }
        return $rules;
    }

    /**
     * Get the presets of the file for apply after upload
     *
     * @param string $attribute Attribute name of the model
     * @return array
     */
    public function getFilePresetAfterUpload($attribute)
    {
        $preset = $this->getFileOption($attribute, 'applyPresetAfterUpload');
        if (is_string($preset) && $preset === '*') {
            return array_keys($this->getFileOption($attribute, 'preset', []));
        } elseif (is_array($preset)) {
            return $preset;
        }

        return [];
    }

    /**
     * Get a description of the validation rules in as text
     *
     * Example
     *
     * ```php
     * $form->field($model, $attribute)->hint($model->getFileRulesDescription($attribute)
     * ```
     *
     * Output
     *
     * ```
     * Min. size of image: 300x300px
     * File types: JPG, JPEG, PNG
     * Max. file size: 1.049 MB
     * ```
     *
     * @param string $attribute Attribute name of the model
     * @return string
     */
    public function getFileRulesDescription($attribute)
    {
        return FormatValidation::getDescription($this->getFileOption($attribute, 'rules', []));
    }

    /**
     * Generate a thumb name
     *
     * @param string $path The path of the file
     * @param string $prefix Prefix for name of the file
     * @return string
     */
    public function generateThumbName($path, $prefix)
    {
        $fileName = pathinfo($path, PATHINFO_FILENAME);
        return str_replace($fileName, $prefix . '_' . $fileName, $path);
    }

    /**
     * Create a thumb
     *
     * @param string $attribute Attribute name of the model
     * @param string $preset The name of the preset
     * @return string
     */
    public function thumb($attribute, $preset, $file = null)
    {
        $path = $this->getTemplatePath($attribute, $file);
        return $this->generateThumb($attribute, $preset, $path);
    }

    /**
     * Create a thumb and return full path
     *
     * @param string $attribute Attribute name of the model
     * @param string $preset The name of the preset
     * @return string
     */
    public function thumbFullPath($attribute, $preset, $file = null)
    {
        $path = $this->getTemplatePath($attribute, $file);
        $realPath = $this->getFileOption($attribute, 'basePath');
        $thumbPath = $this->generateThumb($attribute, $preset, $path);
        return $realPath . $thumbPath;
    }
}