SleepingOwl\Admin\Form\Element\Files

Complexity

Total Complexity

54

Size/Duplication

Total Lines	413
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

30 Methods

Rating	Name	Duplication	Size	Complexity
A	saveFile()	0	12	2
A	getUploadPath()	0	7	2
A	setDriver()	0	6	1
A	getUploadValidationLabels()	0	3	1
A	setUploadFileName()	0	5	1
A	minSize()	0	5	1
A	setHorizontal()	0	5	1
A	getValueFromModel()	0	6	3
A	customValidation()	0	2	1
A	getUploadValidationMessages()	0	8	2
A	showTitle()	0	5	1
A	setSaveCallback()	0	5	1
A	getUploadValidationRules()	0	3	1
A	setVertical()	0	5	1
A	defaultUploadFilename()	0	3	1
A	showDescription()	0	5	1
A	defaultUploadPath()	0	3	1
A	getUploadSettings()	0	7	3
A	setUploadSettings()	0	5	1
A	getSaveCallback()	0	3	1
A	getDriver()	0	3	1
A	setUploadPath()	0	5	1
A	addValidationRule()	0	17	4
A	setListMode()	0	9	3
A	getUploadFileName()	0	7	2
A	maxSize()	0	5	1
A	setTitleRequired()	0	5	1
A	setDescriptionRequired()	0	5	1
C	save()	0	38	12
A	toArray()	0	13	1

<?php

namespace SleepingOwl\Admin\Form\Element;

use Closure;
use Illuminate\Support\Arr;
use Illuminate\Http\Request;
use Illuminate\Http\UploadedFile;
use KodiComponents\Support\Upload;

This use statement conflicts with another class in this namespace, SleepingOwl\Admin\Form\Element\Upload. Consider defining an alias.

use Illuminate\Support\Facades\File;

This use statement conflicts with another class in this namespace, SleepingOwl\Admin\Form\Element\File. Consider defining an alias.

class Files extends Images
{
    protected $uploadValidationRules = ['required'];

    protected $view = 'form.element.files';

    protected $files_group_class = null;

    protected $show_title = true;

    protected $show_description = true;

    protected $title_required = false;

    protected $description_required = false;

    /**
     * @param bool $bool
     *
     * @return $this
     */
    public function showTitle($bool)
    {
        $this->show_title = $bool;

        return $this;
    }

    /**
     * @param bool $bool
     *
     * @return $this
     */
    public function showDescription($bool)
    {
        $this->show_description = $bool;

        return $this;
    }

    /**
     * @param bool $bool
     *
     * @return $this
     */
    public function setTitleRequired($bool)
    {
        $this->title_required = $bool;

        return $this;
    }

    /**
     * @param bool $bool
     *
     * @return $this
     */
    public function setDescriptionRequired($bool)
    {
        $this->description_required = $bool;

        return $this;
    }

    /**
     * @return array
     */
    public function getUploadValidationMessages()
    {
        $messages = [];
        foreach ($this->validationMessages as $rule => $message) {
            $messages["file.{$rule}"] = $message;
        }

        return $messages;
    }

    /**
     * @return array
     */
    public function getUploadValidationLabels()
    {
        return ['file' => $this->getLabel()];
    }

    /**
     * @param $driver
     * @param array $driverOptions
     * @return $this
     */
    public function setDriver($driver, $driverOptions = [])
    {
        $this->driver = $driver;
        $this->driverOptions = $driverOptions;

        return $this;
    }

    /**
     * @return array
     */
    public function getDriver()
    {
        return ['driver' => $this->driver, 'driverOptions' => $this->driverOptions];
    }

    /**
     * @return array
     */
    public function getUploadValidationRules()
    {
        return ['file' => array_unique($this->uploadValidationRules)];
    }

    /**
     * @param UploadedFile $file
     *
     * @return mixed
     */
    public function getUploadPath(UploadedFile $file)
    {
        if (! is_callable($this->uploadPath)) {
            return $this->defaultUploadPath($file);
        }

        return call_user_func($this->uploadPath, $file);
    }

    /**
     * @param Closure $uploadPath
     *
     * @return $this
     */
    public function setUploadPath(Closure $uploadPath)
    {
        $this->uploadPath = $uploadPath;

        return $this;
    }

    /**
     * @param UploadedFile $file
     *
     * @return string
     */
    public function getUploadFileName(UploadedFile $file)
    {
        if (! is_callable($this->uploadFileName)) {
            return $this->defaultUploadFilename($file);
        }

        return call_user_func($this->uploadFileName, $file);
    }

    /**
     * @param Closure $uploadFileName
     *
     * @return $this
     */
    public function setUploadFileName(Closure $uploadFileName)
    {
        $this->uploadFileName = $uploadFileName;

        return $this;
    }

    /**
     * @return array
     */
    public function getUploadSettings()
    {
        if (empty($this->uploadSettings) && in_array(Upload::class, class_uses($this->getModel()))) {
            return (array) array_get($this->getModel()->getUploadSettings(), $this->getPath());

The function array_get was not found. Maybe you did not declare it correctly or list all dependencies?

        }

        return $this->uploadSettings;
    }

    /**
     * @param array $imageSettings
     *
     * @return $this
     */
    public function setUploadSettings(array $imageSettings)
    {
        $this->uploadSettings = $imageSettings;

        return $this;
    }

    /**
     * @param string $rule
     * @param null $message

Are you sure the doc-type for parameter $message is correct as it would always require null to be passed?

     * @return $this|\SleepingOwl\Admin\Form\Element\File|\SleepingOwl\Admin\Form\Element\NamedFormElement
     */
    public function addValidationRule($rule, $message = null)
    {
        $uploadRules = ['file', 'image', 'mime', 'size', 'dimensions', 'max', 'min', 'between'];

        foreach ($uploadRules as $uploadRule) {
            if (strpos($rule, $uploadRule) !== false) {
                $this->uploadValidationRules[] = $rule;

                if (is_null($message)) {
                    return $this;
                }

                return $this->addValidationMessage($rule, $message);
            }
        }

        return parent::addValidationRule($rule, $message);
    }

    /**
     * @param int $size Max size in kilobytes
     *
     * @return $this
     */
    public function maxSize($size)
    {
        $this->addValidationRule('max:'.(int) $size);

        return $this;
    }

    /**
     * @param int $size Max size in kilobytes
     *
     * @return $this
     */
    public function minSize($size)
    {
        $this->addValidationRule('min:'.(int) $size);

        return $this;
    }

    /**
     * @param \Closure $callable
     * @return $this
     */
    public function setSaveCallback(\Closure $callable)
    {
        $this->saveCallback = $callable;

        return $this;
    }

    /**
     * Return save callback.
     * @return \Closure
     */
    public function getSaveCallback()
    {
        return $this->saveCallback;
    }

    /**
     * @param UploadedFile $file
     * @param string $path
     * @param string $filename
     * @param array $settings
     * @return \Closure|array
     */
    public function saveFile(UploadedFile $file, $path, $filename, array $settings)
    {
        if (is_callable($callback = $this->getSaveCallback())) {
            return $callback($file, $path, $filename, $settings);
        }

        $file->move($path, $filename);

        //S3 Implement
        $value = $path.'/'.$filename;

        return ['path' => asset($value), 'value' => $value];
    }

    /**
     * @param \Illuminate\Validation\Validator $validator
     */
    public function customValidation(\Illuminate\Validation\Validator $validator)
    {
    }

    /**
     * @param UploadedFile $file
     *
     * @return string
     */
    public function defaultUploadFilename(UploadedFile $file)
    {
        return md5(time().$file->getClientOriginalName()).'.'.$file->getClientOriginalExtension();
    }

    /**
     * @param UploadedFile $file
     *
     * @return string
     */
    public function defaultUploadPath(UploadedFile $file)
    {
        return config('sleeping_owl.filesUploadDirectory', 'files/uploads');
    }

    /**
     * @return array|mixed|string
     */
    public function getValueFromModel()
    {
        $value = $this->model->{$this->name};
        $return = isset($value) && mb_strlen($value) >= 5 ? json_decode($value, true) : [];

        return $return;
    }

    /**
     * @param string $mode
     *
     * @return $this
     */
    public function setListMode($mode)
    {
        if ($mode == 'vertical') {
            $this->files_group_class = 'files-group-vertical';
        } elseif ($mode == 'horizontal') {
            $this->files_group_class = null;
        }

        return $this;
    }

    /**
     * @return $this
     */
    public function setVertical()
    {
        $this->setListMode('vertical');

        return $this;
    }

    /**
     * @return $this
     */
    public function setHorizontal()
    {
        $this->setListMode('horizontal');

        return $this;
    }

    /**
     * @param Request $request
     */
    public function save(Request $request)
    {
        $name = $this->getName();
        $value = Arr::get($request->all(), $this->getNameKey());

        if (is_array($value_array = json_decode($value, true)) && count($value_array)) {
            foreach ($value_array as $v => $array) {
                $file = $array['url'];
                if ($file && File::exists($file)) {
                    if (! isset($array['filesize'])) {
                        $array['filesize'] = File::size($file);
                    }
                    if (! isset($array['ext'])) {
                        $array['ext'] = File::extension($file);
                    }
                    $mime = File::mimeType($file);
                    if (! isset($array['mime'])) {
                        $array['mime'] = $mime;
                    }
                    if (mb_strpos($mime, '/')) {

It seems like $mime can also be of type false; however, parameter $haystack of mb_strpos() does only seem to accept string, maybe add an additional type check?

                        [$mime1, $mime2] = explode('/', $mime);

It seems like $mime can also be of type false; however, parameter $string of explode() does only seem to accept string, maybe add an additional type check?

                        if (! isset($array['mime_base'])) {
                            $array['mime_base'] = $mime1;
                        }
                        if (! isset($array['mime_detail'])) {
                            $array['mime_detail'] = $mime2;
                        }
                    }
                }
                $value_array[$v] = $array;
            }
            $value = json_encode($value_array);
        }

        $request->merge([$name => $value]);

        $this->setModelAttribute(
            $this->getValueFromRequest($request)
        );
    }

    /**
     * @return array
     */
    public function toArray()
    {
        $return = parent::toArray();

        $return = array_merge($return, [
            'files_group_class' => $this->files_group_class,
            'show_title' => $this->show_title,
            'show_description' => $this->show_description,
            'title_required' => $this->title_required,
            'description_required' => $this->description_required,
        ]);

        return $return;
    }
}