tkanstantsin\fileupload\saver\Uploader

Complexity

Total Complexity

13

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	getFileContent()	0	7	3
A	upload()	0	8	1
A	__construct()	0	8	1
A	rules()	0	5	1
A	init()	0	13	2
A	uploadFile()	0	23	5

<?php
declare(strict_types=1);

namespace tkanstantsin\fileupload\saver;

use League\Flysystem\FilesystemInterface;
use tkanstantsin\fileupload\config\Alias;
use tkanstantsin\fileupload\FileManager;
use tkanstantsin\fileupload\model\Type;
use tkanstantsin\yii2fileupload\model\File;

The type tkanstantsin\yii2fileupload\model\File was not found. Maybe you did not declare it correctly or list all dependencies?

use yii\helpers\ArrayHelper;

The type yii\helpers\ArrayHelper was not found. Maybe you did not declare it correctly or list all dependencies?

use yii\web\UploadedFile;

The type yii\web\UploadedFile was not found. Maybe you did not declare it correctly or list all dependencies?

/**
 * Class FileUpload
 *
 * @todo: create Yii2 independent Uploader and/or split existed uploader.
 */
class Uploader extends File
{
    /**
     * @var FileManager
     */
    public $fileManager;
    /**
     * @var UploadedFile
     */
    public $uploadedFile;
    /**
     * @var Alias
     */
    private $aliasConfig;
    /**
     * @var FilesystemInterface
     */
    private $filesystem;

    /**
     * FileUpload constructor.
     * @param FileManager $fileManager
     * @param UploadedFile $uploadedFile
     * @param array $aliasConfig
     * @param FilesystemInterface $filesystem
     * @param array $config
     */
    public function __construct(FileManager $fileManager, UploadedFile $uploadedFile, Alias $aliasConfig, FilesystemInterface $filesystem, array $config = [])
    {
        $this->fileManager = $fileManager;
        $this->uploadedFile = $uploadedFile;
        $this->aliasConfig = $aliasConfig;
        $this->filesystem = $filesystem;

        parent::__construct($config);
    }

    public function init(): void
    {
        parent::init();

        $this->parent_model = $this->aliasConfig->name;

The property parent_model does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->name = pathinfo($this->uploadedFile->name, PATHINFO_FILENAME);

The property name does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->extension = $this->uploadedFile->extension;

The property extension does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->size = (int) $this->uploadedFile->size;

The property size does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->mime_type = $this->uploadedFile->type;

The property mime_type does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->type_id = Type::getByMimeType((string) $this->mime_type);

The property type_id does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->hash = \is_resource($this->uploadedFile->tempName)

The property hash does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            ? hash('md5', stream_get_contents($this->uploadedFile->tempName))
            : hash_file('md5', $this->uploadedFile->tempName);
    }

    /**
     * @return array
     */
    public function rules(): array
    {
        return ArrayHelper::merge(parent::rules(), [
            [['uploadedFile', 'parent_model'], 'required'],
            [['uploadedFile'], 'file', 'maxSize' => $this->aliasConfig->maxSize],
        ]);
    }

    /**
     * Saves file
     * @return bool
     * @throws \League\Flysystem\FileExistsException
     * @throws \InvalidArgumentException
     */
    public function upload(): bool
    {
        $saved = $this->save();

        // ignore saving error
        $this->uploadFile($this->aliasConfig->getFileDirectory($this), $this->aliasConfig->getFileName($this));

        return $saved;
    }

    /**
     * Copy file into FileSaver::$filesystem
     * @param string $dirPath
     * @param string $fileName
     * @return bool
     * @throws \League\Flysystem\FileExistsException
     * @throws \InvalidArgumentException
     */
    public function uploadFile(string $dirPath, string $fileName): bool
    {
        try {
            if (!$this->filesystem->createDir($dirPath)) {
                return false;
            }

            $targetFilePath = $dirPath . DIRECTORY_SEPARATOR . $fileName;

            if ($this->filesystem->has($targetFilePath)) {
                $this->addError('', "File by path `{$targetFilePath}` already exists.");

                return false;
            }

            $contentResource = $this->getFileContent();

Are you sure the assignment to $contentResource is correct as $this->getFileContent() targeting tkanstantsin\fileupload\saver\Uploader::getFileContent() seems to always return null.

            if ($contentResource === null) {

The condition $contentResource === null is always true.

                return false;
            }

            return $this->filesystem->writeStream($targetFilePath, $contentResource);
        } catch (\Exception $e) {
            return false;
        }
    }

    /**
     * @return resource|null
     */
    private function getFileContent()
    {
        $resource = \is_resource($this->uploadedFile->tempName)
            ? $this->uploadedFile->tempName
            : fopen($this->uploadedFile->tempName, 'rb');

        return $resource ?: null;

$resource is of type false|resource, thus it always evaluated to false.

    }
}