Uploader::addRule() - Code Metrics - Inspection of "resolve" - slince/upload - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2bd67e...423e5d )

by Taosikai

created 2017-04-14 08:00 UTC

Uploader::addRule() A

↳ Parent: Uploader

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
c	0
b	0
f	0
rs	10
cc	1
eloc	2
nc	1
nop	1

<?php
/**
 * slince upload handler library
 * @author Tao <[email protected]>
 */
namespace Slince\Upload;

use Slince\Upload\Exception\UploadException;
use Slince\Upload\Rule\RuleInterface;
use Slince\Upload\Rule\SystemRule;

class Uploader
{
    /**
     * Whether to overwrite if there is a file of the same name
     * @var boolean
     */
    protected $override = false;

    /**
     * save path
     * @var string
     */
    protected $savePath = './';

    /**
     * Whether to enable random file name
     * @var boolean
     */
    protected $isRandName = false;

    /**
     * rules
     * @var RuleInterface[]
     */
    protected $rules = [];

    /**
     * file name generator
     * @var callable
     */
    protected $filenameGenerator;

    public function __construct($path = './')
    {
        $this->setSavePath($path);
        $this->addRule(new SystemRule());
    }

    /**
     * set override mode
     * @param boolean $override
     */
    public function setOverride($override)
    {
        $this->override = $override;
    }

    /**
     * get override mode
     * @return boolean
     */
    public function getOverride()
    {
        return $this->override;
    }

    /**
     * set save path
     * @param string $path
     * @throws UploadException
     */
    public function setSavePath($path)
    {
        if (!file_exists($path)) {
            @mkdir($path, 0777, true);
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
        }
        if (!is_dir($path)) {
            throw new UploadException(sprintf('Path "%s" is not valid', $path));
        }
        $this->savePath = rtrim($path, '\\/') . DIRECTORY_SEPARATOR;
    }

    /**
     * get save path
     * @return string
     */
    public function getSavePath()
    {
        return $this->savePath;
    }

    /**
     * set rand name mode
     * @param boolean $val
     */
    public function setIsRandName($val)
    {
        $this->isRandName = $val;
    }

    /**
     * get rand name mode
     * @return boolean
     */
    public function getIsRandName()
    {
        return $this->isRandName;
    }

    /**
     * set filename generator
     * @param callable $generator
     */
    public function setFilenameGenerator(callable $generator)
    {
        $this->filenameGenerator = $generator;
    }

    /**
     * get current filename generator
     * @return string
     */
    public function getFilenameGenerator()
    {
        if (is_null($this->filenameGenerator)) {
            $this->filenameGenerator = $this->isRandName ? $this->makeDefaultRandFilenameGenerator()
                : $this->makeDefaultOriginFilenameGenerator();
        }
        return $this->filenameGenerator;
    }

    /**
     * add rule
     * @param RuleInterface $rule
     */
    public function addRule(RuleInterface $rule)
    {
        $this->rules[] = $rule;
    }

    /**
     * gets all rules
     * @return array
     */
    public function getRules()
    {
        return (array)$this->rules;
    }

    /**
     * go, process upload
     * @param array $files
     * @throws UploadException
     * @return FileInfo|FileInfo[];

     */
    public function process($files)
    {
        if (empty($files)) {
            throw new UploadException('File array is not valid');
        }
        //multi files
        if (is_array($files['name'])) {
            $_files = [];
            foreach ($files['name'] as $key => $fileName) {
                $file = array(
                    'error' => $files['error'][$key],
                    'name' => $fileName,
                    'size' => $files['size'][$key],
                    'tmp_name' => $files['tmp_name'][$key],
                    'type' => $files['type'][$key]
                );
                $_files[] = $this->processUpload($file);
            }
            return $_files;
        } else {
            return $this->processUpload($files);
        }
    }

    /**
     * process
     * @param array $info
     * @return FileInfo;

     */
    protected function processUpload(array $info)
    {
        $file = FileInfo::fromArray($info);
        if ($this->validateUpload($file)) {
            $newFilePath = $this->generateFilename($file);
            $result = $this->moveUploadedFile($file, $newFilePath);
            if ($result) {
                $file->setPath($newFilePath);
                $file->setHasError(false);
            } else {
                $file->setHasError(true);
            }
        }
        return $file;
    }

    /**
     * validate rules
     * @param FileInfo $file
     * @return boolean
     */
    protected function validateUpload(FileInfo $file)
    {
        foreach ($this->rules as $rule) {
            if (!$rule->validate($file)) {
                $file->setErrorCode($rule->getErrorCode());
                $file->setErrorMsg($rule->getErrorMsg());
                return false;
            }
        }
        return true;
    }

    /**
     * move file
     * Illegal upload files and other unsolicited causes can not be moved to throw an exception
     * @param FileInfo $file
     * @param string $newFilePath
     * @return boolean
     * @throws UploadException
     */
    protected function moveUploadedFile(FileInfo $file, $newFilePath)
    {
        $tmpName = $file->getTmpName();
        if (is_uploaded_file($tmpName)) {
            if (!file_exists($newFilePath) || $this->override) {
                if (!@move_uploaded_file($tmpName, $newFilePath)) {
                    throw new UploadException('Failed to move file');
                }
                return true;
            } else {
                $file->setErrorCode(ErrorStore::ERROR_SAME_NAME_FILE);
                $file->setErrorMsg(sprintf('File "%s" already exists', $file->getOriginName()));
                return false;
            }
        }
        throw new UploadException('The uploaded file is invalid');
    }

    /**
     * make default rand filename generator
     * @return callable
     */
    protected function makeDefaultRandFilenameGenerator()
    {
        return function (FileInfo $file) {
            return $this->savePath . time() . rand(10, 99) . '.' . $file->getExtension();
        };
    }

    /**
     * make default origin filename generator
     * @return callable
     */
    protected function makeDefaultOriginFilenameGenerator()
    {
        return function (FileInfo $file) {
            return $this->savePath . $file->getOriginName();
        };
    }

    /**
     * make new filepath
     * @param FileInfo $file
     * @return string
     */
    protected function generateFilename(FileInfo $file)
    {
        $generator = $this->getFilenameGenerator();
        $path = call_user_func($generator, $file);
        return $path;
    }
}


1			<?php
2			/**
3			* slince upload handler library
4			* @author Tao <[email protected]>
5			*/
6			namespace Slince\Upload;
7
8			use Slince\Upload\Exception\UploadException;
9			use Slince\Upload\Rule\RuleInterface;
10			use Slince\Upload\Rule\SystemRule;
11
12			class Uploader
13			{
14			/**
15			* Whether to overwrite if there is a file of the same name
16			* @var boolean
17			*/
18			protected $override = false;
19
20			/**
21			* save path
22			* @var string
23			*/
24			protected $savePath = './';
25
26			/**
27			* Whether to enable random file name
28			* @var boolean
29			*/
30			protected $isRandName = false;
31
32			/**
33			* rules
34			* @var RuleInterface[]
35			*/
36			protected $rules = [];
37
38			/**
39			* file name generator
40			* @var callable
41			*/
42			protected $filenameGenerator;
43
44			public function __construct($path = './')
45			{
46			$this->setSavePath($path);
47			$this->addRule(new SystemRule());
48			}
49
50			/**
51			* set override mode
52			* @param boolean $override
53			*/
54			public function setOverride($override)
55			{
56			$this->override = $override;
57			}
58
59			/**
60			* get override mode
61			* @return boolean
62			*/
63			public function getOverride()
64			{
65			return $this->override;
66			}
67
68			/**
69			* set save path
70			* @param string $path
71			* @throws UploadException
72			*/
73			public function setSavePath($path)
74			{
75			if (!file_exists($path)) {
76			@mkdir($path, 0777, true);
			0 ignored issues – show Security Best Practice introduced 2017-04-14 07:38 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
77			}
78			if (!is_dir($path)) {
79			throw new UploadException(sprintf('Path "%s" is not valid', $path));
80			}
81			$this->savePath = rtrim($path, '\\/') . DIRECTORY_SEPARATOR;
82			}
83
84			/**
85			* get save path
86			* @return string
87			*/
88			public function getSavePath()
89			{
90			return $this->savePath;
91			}
92
93			/**
94			* set rand name mode
95			* @param boolean $val
96			*/
97			public function setIsRandName($val)
98			{
99			$this->isRandName = $val;
100			}
101
102			/**
103			* get rand name mode
104			* @return boolean
105			*/
106			public function getIsRandName()
107			{
108			return $this->isRandName;
109			}
110
111			/**
112			* set filename generator
113			* @param callable $generator
114			*/
115			public function setFilenameGenerator(callable $generator)
116			{
117			$this->filenameGenerator = $generator;
118			}
119
120			/**
121			* get current filename generator
122			* @return string
123			*/
124			public function getFilenameGenerator()
125			{
126			if (is_null($this->filenameGenerator)) {
127			$this->filenameGenerator = $this->isRandName ? $this->makeDefaultRandFilenameGenerator()
128			: $this->makeDefaultOriginFilenameGenerator();
129			}
130			return $this->filenameGenerator;
131			}
132
133			/**
134			* add rule
135			* @param RuleInterface $rule
136			*/
137			public function addRule(RuleInterface $rule)
138			{
139			$this->rules[] = $rule;
140			}
141
142			/**
143			* gets all rules
144			* @return array
145			*/
146			public function getRules()
147			{
148			return (array)$this->rules;
149			}
150
151			/**
152			* go, process upload
153			* @param array $files
154			* @throws UploadException
155			* @return FileInfo\|FileInfo[];
			0 ignored issues – show Documentation introduced 2017-04-14 07:38 UTC by Report Bug Copy Issue Report The doc-type `FileInfo\|FileInfo[];` could not be parsed: Expected "\|" or "end of type", but got ";" at position 19. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
156			*/
157			public function process($files)
158			{
159			if (empty($files)) {
160			throw new UploadException('File array is not valid');
161			}
162			//multi files
163			if (is_array($files['name'])) {
164			$_files = [];
165			foreach ($files['name'] as $key => $fileName) {
166			$file = array(
167			'error' => $files['error'][$key],
168			'name' => $fileName,
169			'size' => $files['size'][$key],
170			'tmp_name' => $files['tmp_name'][$key],
171			'type' => $files['type'][$key]
172			);
173			$_files[] = $this->processUpload($file);
174			}
175			return $_files;
176			} else {
177			return $this->processUpload($files);
178			}
179			}
180
181			/**
182			* process
183			* @param array $info
184			* @return FileInfo;
			0 ignored issues – show Documentation introduced 2017-04-14 07:38 UTC by Report Bug Copy Issue Report The doc-type `FileInfo;` could not be parsed: Expected "\|" or "end of type", but got ";" at position 8. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
185			*/
186			protected function processUpload(array $info)
187			{
188			$file = FileInfo::fromArray($info);
189			if ($this->validateUpload($file)) {
190			$newFilePath = $this->generateFilename($file);
191			$result = $this->moveUploadedFile($file, $newFilePath);
192			if ($result) {
193			$file->setPath($newFilePath);
194			$file->setHasError(false);
195			} else {
196			$file->setHasError(true);
197			}
198			}
199			return $file;
200			}
201
202			/**
203			* validate rules
204			* @param FileInfo $file
205			* @return boolean
206			*/
207			protected function validateUpload(FileInfo $file)
208			{
209			foreach ($this->rules as $rule) {
210			if (!$rule->validate($file)) {
211			$file->setErrorCode($rule->getErrorCode());
212			$file->setErrorMsg($rule->getErrorMsg());
213			return false;
214			}
215			}
216			return true;
217			}
218
219			/**
220			* move file
221			* Illegal upload files and other unsolicited causes can not be moved to throw an exception
222			* @param FileInfo $file
223			* @param string $newFilePath
224			* @return boolean
225			* @throws UploadException
226			*/
227			protected function moveUploadedFile(FileInfo $file, $newFilePath)
228			{
229			$tmpName = $file->getTmpName();
230			if (is_uploaded_file($tmpName)) {
231			if (!file_exists($newFilePath) \|\| $this->override) {
232			if (!@move_uploaded_file($tmpName, $newFilePath)) {
233			throw new UploadException('Failed to move file');
234			}
235			return true;
236			} else {
237			$file->setErrorCode(ErrorStore::ERROR_SAME_NAME_FILE);
238			$file->setErrorMsg(sprintf('File "%s" already exists', $file->getOriginName()));
239			return false;
240			}
241			}
242			throw new UploadException('The uploaded file is invalid');
243			}
244
245			/**
246			* make default rand filename generator
247			* @return callable
248			*/
249			protected function makeDefaultRandFilenameGenerator()
250			{
251			return function (FileInfo $file) {
252			return $this->savePath . time() . rand(10, 99) . '.' . $file->getExtension();
253			};
254			}
255
256			/**
257			* make default origin filename generator
258			* @return callable
259			*/
260			protected function makeDefaultOriginFilenameGenerator()
261			{
262			return function (FileInfo $file) {
263			return $this->savePath . $file->getOriginName();
264			};
265			}
266
267			/**
268			* make new filepath
269			* @param FileInfo $file
270			* @return string
271			*/
272			protected function generateFilename(FileInfo $file)
273			{
274			$generator = $this->getFilenameGenerator();
275			$path = call_user_func($generator, $file);
276			return $path;
277			}
278			}
279

slince / upload

Push — master ( 2bd67e...423e5d )

Uploader::addRule() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like