BaseFile::getValue() - Code Metrics - Inspection of "i18n" - ScoLib/admin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 85c58c...2c5e88 )

by wen

created 2018-01-12 10:10 UTC

BaseFile::getValue() A

↳ Parent: BaseFile::getActionUrl()

Complexity

Conditions	2
Paths	2

Size

Total Lines	13
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	13
rs	9.4285
c	0
b	0
f	0
nc	2
cc	2
eloc	8
nop	0

<?php

namespace Sco\Admin\Form\Elements;

use Illuminate\Http\UploadedFile;
use Sco\Admin\Facades\Admin;
use Sco\Admin\Traits\UploadStorageTrait;
use Validator;

abstract class BaseFile extends NamedElement
{
    use UploadStorageTrait;

    protected $actionUrl;

    protected $withCredentials = false;

    protected $maxFileSize;

    protected $fileExtensions;

    protected $uploadValidationRules = [];

    protected $uploadValidationMessages = [];

    abstract protected function getDefaultExtensions();

    public function getActionUrl()
    {
        if ($this->actionUrl) {
            return $this->actionUrl;
        }

        $params = [
            'model' => Admin::component()->getName(),
            'field' => $this->getName(),
        ];
        $params['id'] = null;
        if ($this->getModel()->exists) {
            $params['id'] = $this->getModel()->getKey();
        }
        $params['_token'] = csrf_token();

        return route('admin.model.upload.file', $params);
    }

    public function setActionUrl($value)
    {
        $this->actionUrl = $value;

        return $this;
    }

    /**
     * Indicates whether or not cross-site Access-Control requests
     * should be made using credentials
     *
     * @return $this
     */
    public function withCredentials()
    {
        $this->withCredentials = true;

        return $this;
    }

    /**
     * The maximum size of an uploaded file in kilobytes
     *
     * @return int
     */
    public function getMaxFileSize()
    {
        if ($this->maxFileSize) {
            return $this->maxFileSize;
        }

        return $this->getDefaultMaxFileSize();
    }

    protected function getDefaultMaxFileSize()
    {
        return UploadedFile::getMaxFilesize() / 1024;
    }

    /**
     * The maximum size allowed for an uploaded file in kilobytes
     *
     * @param int $value
     *
     * @return $this
     */
    public function setMaxFileSize(int $value)
    {
        $this->maxFileSize = $value;

        $this->addValidationRule('max:' . $this->maxFileSize);

        return $this;
    }

    public function getFileExtensions()
    {
        if ($this->fileExtensions) {
            return $this->fileExtensions;
        }

        return $this->getDefaultExtensions();
    }

    /**
     * A list of allowable extensions that can be uploaded.
     *
     * @param string $value
     *
     * @return $this
     */
    public function setFileExtensions(string $value)
    {
        $this->fileExtensions = $value;

        $this->addValidationRule('mimes:' . $value);

        return $this;
    }

    public function toArray()
    {
        return parent::toArray() + [
                'action'           => $this->getActionUrl(),
                'maxFileSize'      => $this->getMaxFileSize(),
                'fileExtensions'   => $this->getFileExtensions(),
            ];
    }

    /**
     * Save file to storage
     *
     * @param \Illuminate\Http\UploadedFile $file
     *
     * @return array
     * @throws \Illuminate\Validation\ValidationException
     */
    public function saveFile(UploadedFile $file)
    {
        Validator::validate(
            [$this->getName() => $file],
            $this->getUploadValidationRules(),
            $this->getUploadValidationMessages(),
            $this->getUploadValidationTitles()
        );

        $path = $file->storeAs(
            $this->getUploadPath($file),
            $this->getUploadFileName($file),
            $this->getDisk()
        );

        return $this->getFileInfo($path);
    }

    /**
     * Get file info(name,path,url)
     *
     * @param $path
     *
     * @return array
     */
    protected function getFileInfo($path)
    {
        return [
            'name' => substr($path, strrpos($path, '/') + 1),
            'path' => $path,
            'url'  => $this->getFileUrl($path),
        ];
    }

    public function addValidationRule($rule, $message = null)
    {
        $uploadRules = [
            'image',
            'mimes',
            'mimetypes',
            'size',
            'dimensions',
            'max',
            'min',
            'between',
        ];

        if (in_array($this->getValidationRuleName($rule), $uploadRules)) {
            return $this->addUploadValidationRule($rule, $message);
        }

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

    protected function addUploadValidationRule($rule, $message = null)

    {
        $this->uploadValidationRules[$this->getValidationRuleName($rule)] = $rule;

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

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

    protected function addUploadValidationMessage($rule, $message)
    {
        $key = $this->getName() . '.' . $this->getValidationRuleName($rule);

        $this->uploadValidationMessages[$key] = $message;

        return $this;
    }

    protected function getUploadValidationRules()
    {
        $rules = array_merge(
            $this->getDefaultUploadValidationRules(),
            $this->uploadValidationRules
        );

        return [$this->getName() => array_values($rules)];
    }

    /**
     * Get default validation rules
     *
     * @return array
     */
    protected function getDefaultUploadValidationRules()
    {
        return [
            'bail'  => 'bail',
            'file'  => 'file',
            'mimes' => 'mimes:' . $this->getDefaultExtensions(),
            'max'   => 'max:' . $this->getDefaultMaxFileSize(),
        ];
    }

    /**
     * Get validation messages
     *
     * @return array
     */
    protected function getUploadValidationMessages()
    {
        return $this->uploadValidationMessages;
    }

    /**
     * Get validation custom attributes
     *
     * @return array
     */
    protected function getUploadValidationTitles()
    {
        return $this->getValidationTitles();
    }
}


1		<?php
2
3		namespace Sco\Admin\Form\Elements;
4
5		use Illuminate\Http\UploadedFile;
6		use Sco\Admin\Facades\Admin;
7		use Sco\Admin\Traits\UploadStorageTrait;
8		use Validator;
9
10		abstract class BaseFile extends NamedElement
11		{
12		use UploadStorageTrait;
13
14		protected $actionUrl;
15
16		protected $withCredentials = false;
17
18		protected $maxFileSize;
19
20		protected $fileExtensions;
21
22		protected $uploadValidationRules = [];
23
24		protected $uploadValidationMessages = [];
25
26		abstract protected function getDefaultExtensions();
27
28		public function getActionUrl()
29		{
30		if ($this->actionUrl) {
31		return $this->actionUrl;
32		}
33
34		$params = [
35		'model' => Admin::component()->getName(),
36		'field' => $this->getName(),
37		];
38		$params['id'] = null;
39		if ($this->getModel()->exists) {
40		$params['id'] = $this->getModel()->getKey();
41		}
42		$params['_token'] = csrf_token();
43
44		return route('admin.model.upload.file', $params);
45		}
46
47		public function setActionUrl($value)
48		{
49		$this->actionUrl = $value;
50
51		return $this;
52		}
53
54		/**
55		* Indicates whether or not cross-site Access-Control requests
56		* should be made using credentials
57		*
58		* @return $this
59		*/
60		public function withCredentials()
61		{
62		$this->withCredentials = true;
63
64		return $this;
65		}
66
67		/**
68		* The maximum size of an uploaded file in kilobytes
69		*
70		* @return int
71		*/
72		public function getMaxFileSize()
73		{
74		if ($this->maxFileSize) {
75		return $this->maxFileSize;
76		}
77
78		return $this->getDefaultMaxFileSize();
79		}
80
81		protected function getDefaultMaxFileSize()
82		{
83		return UploadedFile::getMaxFilesize() / 1024;
84		}
85
86		/**
87		* The maximum size allowed for an uploaded file in kilobytes
88		*
89		* @param int $value
90		*
91		* @return $this
92		*/
93		public function setMaxFileSize(int $value)
94		{
95		$this->maxFileSize = $value;
96
97		$this->addValidationRule('max:' . $this->maxFileSize);
98
99		return $this;
100		}
101
102		public function getFileExtensions()
103		{
104		if ($this->fileExtensions) {
105		return $this->fileExtensions;
106		}
107
108		return $this->getDefaultExtensions();
109		}
110
111		/**
112		* A list of allowable extensions that can be uploaded.
113		*
114		* @param string $value
115		*
116		* @return $this
117		*/
118		public function setFileExtensions(string $value)
119		{
120		$this->fileExtensions = $value;
121
122		$this->addValidationRule('mimes:' . $value);
123
124		return $this;
125		}
126
127		public function toArray()
128		{
129		return parent::toArray() + [
130		'action' => $this->getActionUrl(),
131		'maxFileSize' => $this->getMaxFileSize(),
132		'fileExtensions' => $this->getFileExtensions(),
133		];
134		}
135
136		/**
137		* Save file to storage
138		*
139		* @param \Illuminate\Http\UploadedFile $file
140		*
141		* @return array
142		* @throws \Illuminate\Validation\ValidationException
143		*/
144		public function saveFile(UploadedFile $file)
145		{
146		Validator::validate(
147		[$this->getName() => $file],
148		$this->getUploadValidationRules(),
149		$this->getUploadValidationMessages(),
150		$this->getUploadValidationTitles()
151		);
152
153		$path = $file->storeAs(
154		$this->getUploadPath($file),
155		$this->getUploadFileName($file),
156		$this->getDisk()
157		);
158
159		return $this->getFileInfo($path);
160		}
161
162		/**
163		* Get file info(name,path,url)
164		*
165		* @param $path
166		*
167		* @return array
168		*/
169		protected function getFileInfo($path)
170		{
171		return [
172		'name' => substr($path, strrpos($path, '/') + 1),
173		'path' => $path,
174		'url' => $this->getFileUrl($path),
175		];
176		}
177
178		public function addValidationRule($rule, $message = null)
179		{
180		$uploadRules = [
181		'image',
182		'mimes',
183		'mimetypes',
184		'size',
185		'dimensions',
186		'max',
187		'min',
188		'between',
189		];
190
191		if (in_array($this->getValidationRuleName($rule), $uploadRules)) {
192		return $this->addUploadValidationRule($rule, $message);
193		}
194
195		return parent::addValidationRule($rule, $message);
196		}
197
198	View Code Duplication	protected function addUploadValidationRule($rule, $message = null)
		0 ignored issues – show Duplication introduced 2017-08-28 10:21 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
199		{
200		$this->uploadValidationRules[$this->getValidationRuleName($rule)] = $rule;
201
202		if (is_null($message)) {
203		return $this;
204		}
205
206		return $this->addUploadValidationMessage($rule, $message);
207		}
208
209		protected function addUploadValidationMessage($rule, $message)
210		{
211		$key = $this->getName() . '.' . $this->getValidationRuleName($rule);
212
213		$this->uploadValidationMessages[$key] = $message;
214
215		return $this;
216		}
217
218		protected function getUploadValidationRules()
219		{
220		$rules = array_merge(
221		$this->getDefaultUploadValidationRules(),
222		$this->uploadValidationRules
223		);
224
225		return [$this->getName() => array_values($rules)];
226		}
227
228		/**
229		* Get default validation rules
230		*
231		* @return array
232		*/
233		protected function getDefaultUploadValidationRules()
234		{
235		return [
236		'bail' => 'bail',
237		'file' => 'file',
238		'mimes' => 'mimes:' . $this->getDefaultExtensions(),
239		'max' => 'max:' . $this->getDefaultMaxFileSize(),
240		];
241		}
242
243		/**
244		* Get validation messages
245		*
246		* @return array
247		*/
248		protected function getUploadValidationMessages()
249		{
250		return $this->uploadValidationMessages;
251		}
252
253		/**
254		* Get validation custom attributes
255		*
256		* @return array
257		*/
258		protected function getUploadValidationTitles()
259		{
260		return $this->getValidationTitles();
261		}
262		}
263

ScoLib / admin

Push — master ( 85c58c...2c5e88 )

BaseFile::getValue() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like