rkit\filemanager\behaviors\FileBehavior

Complexity

Total Complexity

66

Size/Duplication

Total Lines	476
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	6	1
A	events()	0	10	1
A	beforeSave()	0	10	4
C	afterSave()	0	31	8
A	beforeDelete()	0	6	2
A	deleteFiles()	0	12	3
B	deleteCurrentFiles()	0	15	5
A	bindSingle()	0	14	3
B	bindMultiple()	0	23	5
A	getFilePathValue()	0	9	4
A	getFileStorage()	0	9	2
A	generateThumb()	0	16	4
A	prepareFile()	0	18	3
A	getFileOption()	0	4	1
A	getFilePath()	0	4	1
A	getFileUrl()	0	4	1
A	getFileOwnerType()	0	4	1
A	getFiles()	0	4	1
A	getFile()	0	4	1
A	getFileRules()	0	9	3
A	getFilePresetAfterUpload()	0	11	4
A	getFileRulesDescription()	0	4	1
A	generateThumbName()	0	5	1
A	thumb()	0	4	1
A	thumbFullPath()	0	6	1
A	createFile()	0	17	4

<?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\helpers\ArrayHelper;
use yii\base\InvalidParamException;
use rkit\filemanager\models\File;
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) {
            $fileId = $this->owner->{$attribute};
            $isAttributeNotChanged = $options['isAttributeChanged'] === false || $fileId === null;

            if ($isAttributeNotChanged) {
                continue;
            }

            $ownerId = $this->owner->primaryKey;
            $ownerType = $this->getFileOwnerType($attribute);

            if ($fileId === [] || $fileId === '') {
                $this->deleteFiles($attribute, $ownerId, $ownerType);
                continue;
            }

            if ($this->getFileOption($attribute, 'multiple')) {
                $this->bindMultiple($attribute, $ownerId, $ownerType, $fileId);
                return;
            }

            $file = $this->bindSingle($attribute, $ownerId, $ownerType, $fileId);
            if ($this->getFileOption($attribute, 'saveFilePath')) {
                $this->owner->updateAttributes([
                    $attribute => $this->getFilePathValue($file, $options['oldValue'])
                ]);
            }
        }
    }

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

    /**
     * Delete files
     *
     * @param string $attribute Attribute name of the model
     * @param int $ownerId The id of the owner
     * @param int $ownerType The type of the owner
     */
    private function deleteFiles($attribute, $ownerId, $ownerType)
    {
        $storage = $this->getFileStorage($attribute);
        $realPath = $this->getFileOption($attribute, 'basePath');

        $files = File::findAllByOwner($ownerId, $ownerType);
        foreach ($files as $file) {
            if ($file->delete()) {
                $storage->deleteDir($realPath . $file->path());
            }
        }
    }

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

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

     * @param int $ownerId The id of the owner
     * @param int $ownerType The type of the owner
     * @param rkit\filemanager\models\File[] $exceptFiles
     */
    private function deleteCurrentFiles($attribute, $ownerId, $ownerType, $exceptFiles = [])
    {
        $storage = $this->getFileStorage($attribute);
        $realPath = $this->getFileOption($attribute, 'basePath');

        $currentFiles = File::findAllByOwner($ownerId, $ownerType);
        foreach ($currentFiles as $currFile) {
            $isExceptFiles = count($exceptFiles) && array_key_exists($currFile->id, $exceptFiles);
            if (!$isExceptFiles) {
                if ($currFile->delete()) {
                    $storage->deleteDir($realPath . $currFile->path());
                }
            }
        }
    }

    /**
     * Bind the file to the with owner
     * @internal
     *
     * @param Storage $storage The storage for the file

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

     * @param int $ownerId The id of the owner
     * @param int $ownerType The type of the owner
     * @param int $fileId The id of the file
     * @return rkit\filemanager\models\File|bool
     */
    private function bindSingle($attribute, $ownerId, $ownerType, $fileId)
    {
        $file = File::findOne($fileId);
        if ($file && $file->checkAccess($ownerId, $ownerType)) {

The method checkAccess cannot be called on $file (of type array|boolean).

            $file->tmp = false;
            $file->owner_id = $ownerId;
            $this->deleteCurrentFiles($attribute, $ownerId, $ownerType, [$file->id => $file]);

array($file->id => $file) is of type array<?,array|boolean>, but the function expects a array<integer,object<rkit\filemanager\behaviors\rkit\filemanager\models\File>>.

            $file->updateAttributes($file->getDirtyAttributes());

The method getDirtyAttributes cannot be called on $file (of type array|boolean).

The method updateAttributes cannot be called on $file (of type array|boolean).

            return $file;
        }

        return false;
    }

    /**
     * Bind files to the with owner
     *
     * @param Storage $storage The storage for the files

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

     * @param int $ownerId The id of the owner
     * @param int $ownerType The type of the owner
     * @param array $files Array of ids
     * @return rkit\filemanager\models\File[]|bool
     * @SuppressWarnings(PHPMD.ElseExpression)
     */
    private function bindMultiple($attribute, $ownerId, $ownerType, $files)
    {
        $newFiles = ArrayHelper::index(File::findAll(array_keys($files)), 'id');
        if (count($newFiles)) {
            foreach ($newFiles as $fileId => $file) {
                if ($file->checkAccess($ownerId, $ownerType)) {
                    $file->tmp = false;
                    $file->owner_id = $ownerId;
                    $file->position = (int)array_search($file->id, array_keys($files)) + 1;
                    $file->title = ArrayHelper::getValue($files, $file->id, $file->title);
                    $file->updateAttributes($file->getDirtyAttributes());

                    continue;
                }
                unset($newFiles[$fileId]);
                continue;
            }
            $this->deleteCurrentFiles($attribute, $ownerId, $ownerType, $newFiles);
        } else {
            $this->deleteCurrentFiles($attribute, $ownerId, $ownerType);
        }
        return count($newFiles) ? $newFiles : false;
    }

    /**
     * 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 getFilePathValue($file, $defaultValue)
    {
        if (is_object($file)) {
            return $file->path();
        } elseif ($file === false && $defaultValue !== null) {
            return $defaultValue;
        }
        return '';
    }

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

        throw new InvalidParamException('The storage is not defined'); // @codeCoverageIgnore
    }

    /**
     * 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;
    }

    /**
     * Prepare a new file
     *
     * @param string $attribute Attribute name of the model
     * @param string $path File path
     * @param string $title File title
     * @return File
     */
    private function prepareFile($attribute, $path, $title)
    {
        $isAllowEmptyOwnerId = $this->getFileOption($attribute, 'allowEmptyOwnerId');

        $tmp = true;
        if ($this->owner->primaryKey !== null || $isAllowEmptyOwnerId) {
            $tmp = false;
        }

        $file = new File();
        $file->tmp = $tmp;
        $file->title = $title;
        $file->owner_id = $this->owner->primaryKey;
        $file->owner_type = $this->getFileOwnerType($attribute);
        $file->fillMetaInfo($path);

        return $file;
    }

    /**
     * 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 file path
     *
     * @param string $attribute Attribute name of the model
     * @return string
     */
    public function getFilePath($attribute)
    {
        return $this->getFileOption($attribute, 'basePath') . $this->owner->{$attribute};
    }

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

    /**
     * Get the type of the owner
     *
     * @param string $attribute Attribute name of the model
     * @return int
     */
    public function getFileOwnerType($attribute)
    {
        return Yii::$app->fileManager->getOwnerType($this->owner->tableName() . '.' . $attribute);
    }

    /**
     * Get files
     *
     * @param string $attribute Attribute name of the model
     * @return array
     */
    public function getFiles($attribute)
    {
        return File::findAllByOwner($this->owner->primaryKey, $this->getFileOwnerType($attribute));
    }

    /**
     * Get the file
     *
     * @param string $attribute Attribute name of the model
     * @return File|null
     */
    public function getFile($attribute)
    {
        return File::findOneByOwner($this->owner->primaryKey, $this->getFileOwnerType($attribute));
    }

    /**
     * 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)
    {
        return $this->generateThumb($attribute, $preset, $this->owner->$attribute);
    }

    /**
     * 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)
    {
        $realPath = $this->getFileOption($attribute, 'basePath');
        $thumbPath = $this->generateThumb($attribute, $preset, $this->owner->$attribute);
        return $realPath . $thumbPath;
    }

    /**
     * Create a file
     *
     * @param string $attribute Attribute name of the model
     * @param string $path File path
     * @param string $title File title
     * @return rkit\filemanager\models\File
     */
    public function createFile($attribute, $path, $title = null)
    {
        if (!file_exists($path)) {
            return false;
        }

        $file = $this->prepareFile($attribute, $path, $title);
        if ($file->save()) {
            $storage = $this->getFileStorage($attribute);
            $realPath = $this->getFileOption($attribute, 'basePath');
            if ($storage->saveFile($path, $realPath . $file->path())) {
                $this->owner->{$attribute} = $file->path();
                return $file;
            }
        } // @codeCoverageIgnore
        return false; // @codeCoverageIgnore
    }
}