FileValidator::validateExtension() - Code Metrics - Inspection of "`yii\validators\EachValidator` injects specific at..." - yiisoft/yii2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 11139-each-validator-attribute... ( a0e614 )

by Dmitry

created 2016-03-20 14:35 UTC

FileValidator::validateExtension() B

↳ Parent: FileValidator

Complexity

Conditions	5
Paths	6

Size

Total Lines	24
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	8.9038

Metric	Value
dl	0
loc	24
ccs	6
cts	13
cp	0.4615
rs	8.5125
cc	5
eloc	12
nc	6
nop	1
crap	8.9038

<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\validators;

use Yii;
use yii\helpers\Html;
use yii\helpers\Json;
use yii\web\JsExpression;
use yii\web\UploadedFile;
use yii\helpers\FileHelper;

/**
 * FileValidator verifies if an attribute is receiving a valid uploaded file.
 *
 * Note that you should enable `fileinfo` PHP extension.
 *
 * @property integer $sizeLimit The size limit for uploaded files. This property is read-only.
 *
 * @author Qiang Xue <[email protected]>
 * @since 2.0
 */
class FileValidator extends Validator
{
    /**
     * @var array|string a list of file name extensions that are allowed to be uploaded.
     * This can be either an array or a string consisting of file extension names
     * separated by space or comma (e.g. "gif, jpg").
     * Extension names are case-insensitive. Defaults to null, meaning all file name
     * extensions are allowed.
     * @see wrongExtension for the customized message for wrong file type.
     */
    public $extensions;
    /**
     * @var boolean whether to check file type (extension) with mime-type. If extension produced by
     * file mime-type check differs from uploaded file extension, the file will be considered as invalid.
     */
    public $checkExtensionByMimeType = true;
    /**
     * @var array|string a list of file MIME types that are allowed to be uploaded.
     * This can be either an array or a string consisting of file MIME types
     * separated by space or comma (e.g. "text/plain, image/png").
     * The mask with the special character `*` can be used to match groups of mime types.
     * For example `image/*` will pass all mime types, that begin with `image/` (e.g. `image/jpeg`, `image/png`).
     * Mime type names are case-insensitive. Defaults to null, meaning all MIME types are allowed.
     * @see wrongMimeType for the customized message for wrong MIME type.
     */
    public $mimeTypes;
    /**
     * @var integer the minimum number of bytes required for the uploaded file.
     * Defaults to null, meaning no limit.
     * @see tooSmall for the customized message for a file that is too small.
     */
    public $minSize;
    /**
     * @var integer the maximum number of bytes required for the uploaded file.
     * Defaults to null, meaning no limit.
     * Note, the size limit is also affected by `upload_max_filesize` and `post_max_size` INI setting
     * and the 'MAX_FILE_SIZE' hidden field value. See [[getSizeLimit()]] for details.
     * @see http://php.net/manual/en/ini.core.php#ini.upload-max-filesize
     * @see http://php.net/post-max-size
     * @see getSizeLimit
     * @see tooBig for the customized message for a file that is too big.
     */
    public $maxSize;
    /**
     * @var integer the maximum file count the given attribute can hold.
     * Defaults to 1, meaning single file upload. By defining a higher number,
     * multiple uploads become possible. Setting it to `0` means there is no limit on
     * the number of files that can be uploaded simultaneously.
     *
     * > Note: The maximum number of files allowed to be uploaded simultaneously is
     * also limited with PHP directive `max_file_uploads`, which defaults to 20.
     *
     * @see http://php.net/manual/en/ini.core.php#ini.max-file-uploads
     * @see tooMany for the customized message when too many files are uploaded.
     */
    public $maxFiles = 1;
    /**
     * @var string the error message used when a file is not uploaded correctly.
     */
    public $message;
    /**
     * @var string the error message used when no file is uploaded.
     * Note that this is the text of the validation error message. To make uploading files required,
     * you have to set [[skipOnEmpty]] to `false`.
     */
    public $uploadRequired;
    /**
     * @var string the error message used when the uploaded file is too large.
     * You may use the following tokens in the message:
     *
     * - {attribute}: the attribute name
     * - {file}: the uploaded file name
     * - {limit}: the maximum size allowed (see [[getSizeLimit()]])
     * - {formattedLimit}: the maximum size formatted
     *   with [[\yii\i18n\Formatter::asShortSize()|Formatter::asShortSize()]]
     */
    public $tooBig;
    /**
     * @var string the error message used when the uploaded file is too small.
     * You may use the following tokens in the message:
     *
     * - {attribute}: the attribute name
     * - {file}: the uploaded file name
     * - {limit}: the value of [[minSize]]
     * - {formattedLimit}: the value of [[minSize]] formatted
     *   with [[\yii\i18n\Formatter::asShortSize()|Formatter::asShortSize()]
     */
    public $tooSmall;
    /**
     * @var string the error message used if the count of multiple uploads exceeds limit.
     * You may use the following tokens in the message:
     *
     * - {attribute}: the attribute name
     * - {limit}: the value of [[maxFiles]]
     */
    public $tooMany;
    /**
     * @var string the error message used when the uploaded file has an extension name
     * that is not listed in [[extensions]]. You may use the following tokens in the message:
     *
     * - {attribute}: the attribute name
     * - {file}: the uploaded file name
     * - {extensions}: the list of the allowed extensions.
     */
    public $wrongExtension;
    /**
     * @var string the error message used when the file has an mime type
     * that is not allowed by [[mimeTypes]] property.
     * You may use the following tokens in the message:
     *
     * - {attribute}: the attribute name
     * - {file}: the uploaded file name
     * - {mimeTypes}: the value of [[mimeTypes]]
     */
    public $wrongMimeType;


    /**
     * @inheritdoc
     */
    public function init()
    {
        parent::init();
        if ($this->message === null) {
            $this->message = Yii::t('yii', 'File upload failed.');
        }
        if ($this->uploadRequired === null) {
            $this->uploadRequired = Yii::t('yii', 'Please upload a file.');
        }
        if ($this->tooMany === null) {
            $this->tooMany = Yii::t('yii', 'You can upload at most {limit, number} {limit, plural, one{file} other{files}}.');
        }
        if ($this->wrongExtension === null) {
            $this->wrongExtension = Yii::t('yii', 'Only files with these extensions are allowed: {extensions}.');
        }
        if ($this->tooBig === null) {
            $this->tooBig = Yii::t('yii', 'The file "{file}" is too big. Its size cannot exceed {formattedLimit}.');
        }
        if ($this->tooSmall === null) {
            $this->tooSmall = Yii::t('yii', 'The file "{file}" is too small. Its size cannot be smaller than {formattedLimit}.');
        }
        if (!is_array($this->extensions)) {
            $this->extensions = preg_split('/[\s,]+/', strtolower($this->extensions), -1, PREG_SPLIT_NO_EMPTY);
        } else {
            $this->extensions = array_map('strtolower', $this->extensions);
        }
        if ($this->wrongMimeType === null) {
            $this->wrongMimeType = Yii::t('yii', 'Only files with these MIME types are allowed: {mimeTypes}.');
        }
        if (!is_array($this->mimeTypes)) {
            $this->mimeTypes = preg_split('/[\s,]+/', strtolower($this->mimeTypes), -1, PREG_SPLIT_NO_EMPTY);
        } else {
            $this->mimeTypes = array_map('strtolower', $this->mimeTypes);
        }
    }

    /**
     * @inheritdoc
     */
    public function validateAttribute($model, $attribute)
    {
        if ($this->maxFiles != 1) {
            $files = $model->$attribute;
            if (!is_array($files)) {
                $this->addError($model, $attribute, $this->uploadRequired);

                return;
            }
            foreach ($files as $i => $file) {
                if (!$file instanceof UploadedFile || $file->error == UPLOAD_ERR_NO_FILE) {
                    unset($files[$i]);
                }
            }
            $model->$attribute = array_values($files);
            if (empty($files)) {
                $this->addError($model, $attribute, $this->uploadRequired);
            }
            if ($this->maxFiles && count($files) > $this->maxFiles) {
                $this->addError($model, $attribute, $this->tooMany, ['limit' => $this->maxFiles]);
            } else {
                foreach ($files as $file) {
                    $result = $this->validateValue($file);
                    if (!empty($result)) {
                        $this->addError($model, $attribute, $result[0], $result[1]);
                    }
                }
            }
        } else {
            $result = $this->validateValue($model->$attribute);
            if (!empty($result)) {
                $this->addError($model, $attribute, $result[0], $result[1]);
            }
        }
    }

    /**
     * @inheritdoc
     */
    protected function validateValue($file)
    {
        if (!$file instanceof UploadedFile || $file->error == UPLOAD_ERR_NO_FILE) {
            return [$this->uploadRequired, []];
        }

        switch ($file->error) {
            case UPLOAD_ERR_OK:
                if ($this->maxSize !== null && $file->size > $this->getSizeLimit()) {
                    return [
                        $this->tooBig,
                        [
                            'file' => $file->name,
                            'limit' => $this->getSizeLimit(),
                            'formattedLimit' => Yii::$app->formatter->asShortSize($this->getSizeLimit())
                        ]
                    ];
                } elseif ($this->minSize !== null && $file->size < $this->minSize) {
                    return [
                        $this->tooSmall,
                        [
                            'file' => $file->name,
                            'limit' => $this->minSize,
                            'formattedLimit' => Yii::$app->formatter->asShortSize($this->minSize)
                        ]
                    ];
                } elseif (!empty($this->extensions) && !$this->validateExtension($file)) {
                    return [$this->wrongExtension, ['file' => $file->name, 'extensions' => implode(', ', $this->extensions)]];
                } elseif (!empty($this->mimeTypes) &&  !$this->validateMimeType($file)) {
                    return [$this->wrongMimeType, ['file' => $file->name, 'mimeTypes' => implode(', ', $this->mimeTypes)]];
                } else {
                    return null;
                }
            case UPLOAD_ERR_INI_SIZE:
            case UPLOAD_ERR_FORM_SIZE:
                return [$this->tooBig, [
                    'file' => $file->name,
                    'limit' => $this->getSizeLimit(),
                    'formattedLimit' => Yii::$app->formatter->asShortSize($this->getSizeLimit())
                ]];
            case UPLOAD_ERR_PARTIAL:
                Yii::warning('File was only partially uploaded: ' . $file->name, __METHOD__);
                break;
            case UPLOAD_ERR_NO_TMP_DIR:
                Yii::warning('Missing the temporary folder to store the uploaded file: ' . $file->name, __METHOD__);
                break;
            case UPLOAD_ERR_CANT_WRITE:
                Yii::warning('Failed to write the uploaded file to disk: ' . $file->name, __METHOD__);
                break;
            case UPLOAD_ERR_EXTENSION:
                Yii::warning('File upload was stopped by some PHP extension: ' . $file->name, __METHOD__);
                break;
            default:
                break;
        }

        return [$this->message, []];
    }

    /**
     * Returns the maximum size allowed for uploaded files.
     * This is determined based on four factors:
     *
     * - 'upload_max_filesize' in php.ini
     * - 'post_max_size' in php.ini
     * - 'MAX_FILE_SIZE' hidden field
     * - [[maxSize]]
     *
     * @return integer the size limit for uploaded files.
     */
    public function getSizeLimit()
    {
        // Get the lowest between post_max_size and upload_max_filesize, log a warning if the first is < than the latter
        $limit = $this->sizeToBytes(ini_get('upload_max_filesize'));
        $postLimit = $this->sizeToBytes(ini_get('post_max_size'));
        if ($postLimit > 0 && $postLimit < $limit) {
            Yii::warning('PHP.ini\'s \'post_max_size\' is less than \'upload_max_filesize\'.', __METHOD__);
            $limit = $postLimit;
        }
        if ($this->maxSize !== null && $limit > 0 && $this->maxSize < $limit) {
            $limit = $this->maxSize;
        }
        if (isset($_POST['MAX_FILE_SIZE']) && $_POST['MAX_FILE_SIZE'] > 0 && $_POST['MAX_FILE_SIZE'] < $limit) {
            $limit = (int) $_POST['MAX_FILE_SIZE'];
        }

        return $limit;
    }

    /**
     * @inheritdoc
     */
    public function isEmpty($value, $trim = false)

    {
        $value = is_array($value) ? reset($value) : $value;
        return !($value instanceof UploadedFile) || $value->error == UPLOAD_ERR_NO_FILE;
    }

    /**
     * Converts php.ini style size to bytes
     *
     * @param string $sizeStr $sizeStr
     * @return integer
     */
    private function sizeToBytes($sizeStr)
    {
        switch (substr($sizeStr, -1)) {
            case 'M':
            case 'm':
                return (int) $sizeStr * 1048576;
            case 'K':
            case 'k':
                return (int) $sizeStr * 1024;
            case 'G':
            case 'g':
                return (int) $sizeStr * 1073741824;
            default:
                return (int) $sizeStr;
        }
    }

    /**
     * Checks if given uploaded file have correct type (extension) according current validator settings.
     * @param UploadedFile $file
     * @return boolean
     */
    protected function validateExtension($file)
    {
        $extension = mb_strtolower($file->extension, 'UTF-8');

        if ($this->checkExtensionByMimeType) {

            $mimeType = FileHelper::getMimeType($file->tempName, null, false);
            if ($mimeType === null) {
                return false;
            }

            $extensionsByMimeType = FileHelper::getExtensionsByMimeType($mimeType);

            if (!in_array($extension, $extensionsByMimeType, true)) {
                return false;
            }
        }

        if (!in_array($extension, $this->extensions, true)) {
            return false;
        }

        return true;
    }

    /**
     * @inheritdoc
     */
    public function clientValidateAttribute($model, $attribute, $view)
    {
        ValidationAsset::register($view);
        $options = $this->getClientOptions($model, $attribute);
        return 'yii.validation.file(attribute, messages, ' . Json::encode($options) . ');';
    }

    /**
     * Returns the client side validation options.
     * @param \yii\base\Model $model the model being validated
     * @param string $attribute the attribute name being validated
     * @return array the client side validation options
     */
    protected function getClientOptions($model, $attribute)
    {
        $label = $model->getAttributeLabel($attribute);

        $options = [];
        if ($this->message !== null) {
            $options['message'] = Yii::$app->getI18n()->format($this->message, [
                'attribute' => $label,
            ], Yii::$app->language);
        }

        $options['skipOnEmpty'] = $this->skipOnEmpty;

        if (!$this->skipOnEmpty) {
            $options['uploadRequired'] = Yii::$app->getI18n()->format($this->uploadRequired, [
                'attribute' => $label,
            ], Yii::$app->language);
        }

        if ($this->mimeTypes !== null) {
            $mimeTypes = [];
            foreach ($this->mimeTypes as $mimeType) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                $mimeTypes[] = new JsExpression(Html::escapeJsRegularExpression($this->buildMimeTypeRegexp($mimeType)));
            }
            $options['mimeTypes'] = $mimeTypes;
            $options['wrongMimeType'] = Yii::$app->getI18n()->format($this->wrongMimeType, [
                'attribute' => $label,
                'mimeTypes' => implode(', ', $this->mimeTypes),
            ], Yii::$app->language);
        }

        if ($this->extensions !== null) {
            $options['extensions'] = $this->extensions;
            $options['wrongExtension'] = Yii::$app->getI18n()->format($this->wrongExtension, [
                'attribute' => $label,
                'extensions' => implode(', ', $this->extensions),
            ], Yii::$app->language);
        }

        if ($this->minSize !== null) {
            $options['minSize'] = $this->minSize;
            $options['tooSmall'] = Yii::$app->getI18n()->format($this->tooSmall, [
                'attribute' => $label,
                'limit' => $this->minSize,
                'formattedLimit' => Yii::$app->formatter->asShortSize($this->minSize),
            ], Yii::$app->language);
        }

        if ($this->maxSize !== null) {
            $options['maxSize'] = $this->maxSize;
            $options['tooBig'] = Yii::$app->getI18n()->format($this->tooBig, [
                'attribute' => $label,
                'limit' => $this->getSizeLimit(),
                'formattedLimit' => Yii::$app->formatter->asShortSize($this->getSizeLimit()),
            ], Yii::$app->language);
        }

        if ($this->maxFiles !== null) {
            $options['maxFiles'] = $this->maxFiles;
            $options['tooMany'] = Yii::$app->getI18n()->format($this->tooMany, [
                'attribute' => $label,
                'limit' => $this->maxFiles,
            ], Yii::$app->language);
        }

        return $options;
    }

    /**
     * Builds the RegExp from the $mask
     *
     * @param string $mask
     * @return string the regular expression
     * @see mimeTypes
     */
    private function buildMimeTypeRegexp($mask)
    {
        return '/^' . str_replace('\*', '.*', preg_quote($mask, '/')) . '$/';
    }

    /**
     * Checks the mimeType of the $file against the list in the [[mimeTypes]] property
     *
     * @param UploadedFile $file
     * @return boolean whether the $file mimeType is allowed
     * @throws \yii\base\InvalidConfigException
     * @see mimeTypes
     * @since 2.0.8
     */
    protected function validateMimeType($file)
    {
        $fileMimeType = FileHelper::getMimeType($file->tempName);

        foreach ($this->mimeTypes as $mimeType) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            if ($mimeType === $fileMimeType) {
                return true;
            }

            if (strpos($mimeType, '*') !== false && preg_match($this->buildMimeTypeRegexp($mimeType), $fileMimeType)) {
                return true;
            }
        }

        return false;
    }
}


1		<?php
2		/**
3		* @link http://www.yiiframework.com/
4		* @copyright Copyright (c) 2008 Yii Software LLC
5		* @license http://www.yiiframework.com/license/
6		*/
7
8		namespace yii\validators;
9
10		use Yii;
11		use yii\helpers\Html;
12		use yii\helpers\Json;
13		use yii\web\JsExpression;
14		use yii\web\UploadedFile;
15		use yii\helpers\FileHelper;
16
17		/**
18		* FileValidator verifies if an attribute is receiving a valid uploaded file.
19		*
20		* Note that you should enable `fileinfo` PHP extension.
21		*
22		* @property integer $sizeLimit The size limit for uploaded files. This property is read-only.
23		*
24		* @author Qiang Xue <[email protected]>
25		* @since 2.0
26		*/
27		class FileValidator extends Validator
28		{
29		/**
30		* @var array\|string a list of file name extensions that are allowed to be uploaded.
31		* This can be either an array or a string consisting of file extension names
32		* separated by space or comma (e.g. "gif, jpg").
33		* Extension names are case-insensitive. Defaults to null, meaning all file name
34		* extensions are allowed.
35		* @see wrongExtension for the customized message for wrong file type.
36		*/
37		public $extensions;
38		/**
39		* @var boolean whether to check file type (extension) with mime-type. If extension produced by
40		* file mime-type check differs from uploaded file extension, the file will be considered as invalid.
41		*/
42		public $checkExtensionByMimeType = true;
43		/**
44		* @var array\|string a list of file MIME types that are allowed to be uploaded.
45		* This can be either an array or a string consisting of file MIME types
46		* separated by space or comma (e.g. "text/plain, image/png").
47		* The mask with the special character `*` can be used to match groups of mime types.
48		* For example `image/*` will pass all mime types, that begin with `image/` (e.g. `image/jpeg`, `image/png`).
49		* Mime type names are case-insensitive. Defaults to null, meaning all MIME types are allowed.
50		* @see wrongMimeType for the customized message for wrong MIME type.
51		*/
52		public $mimeTypes;
53		/**
54		* @var integer the minimum number of bytes required for the uploaded file.
55		* Defaults to null, meaning no limit.
56		* @see tooSmall for the customized message for a file that is too small.
57		*/
58		public $minSize;
59		/**
60		* @var integer the maximum number of bytes required for the uploaded file.
61		* Defaults to null, meaning no limit.
62		* Note, the size limit is also affected by `upload_max_filesize` and `post_max_size` INI setting
63		* and the 'MAX_FILE_SIZE' hidden field value. See [[getSizeLimit()]] for details.
64		* @see http://php.net/manual/en/ini.core.php#ini.upload-max-filesize
65		* @see http://php.net/post-max-size
66		* @see getSizeLimit
67		* @see tooBig for the customized message for a file that is too big.
68		*/
69		public $maxSize;
70		/**
71		* @var integer the maximum file count the given attribute can hold.
72		* Defaults to 1, meaning single file upload. By defining a higher number,
73		* multiple uploads become possible. Setting it to `0` means there is no limit on
74		* the number of files that can be uploaded simultaneously.
75		*
76		* > Note: The maximum number of files allowed to be uploaded simultaneously is
77		* also limited with PHP directive `max_file_uploads`, which defaults to 20.
78		*
79		* @see http://php.net/manual/en/ini.core.php#ini.max-file-uploads
80		* @see tooMany for the customized message when too many files are uploaded.
81		*/
82		public $maxFiles = 1;
83		/**
84		* @var string the error message used when a file is not uploaded correctly.
85		*/
86		public $message;
87		/**
88		* @var string the error message used when no file is uploaded.
89		* Note that this is the text of the validation error message. To make uploading files required,
90		* you have to set [[skipOnEmpty]] to `false`.
91		*/
92		public $uploadRequired;
93		/**
94		* @var string the error message used when the uploaded file is too large.
95		* You may use the following tokens in the message:
96		*
97		* - {attribute}: the attribute name
98		* - {file}: the uploaded file name
99		* - {limit}: the maximum size allowed (see [[getSizeLimit()]])
100		* - {formattedLimit}: the maximum size formatted
101		* with [[\yii\i18n\Formatter::asShortSize()\|Formatter::asShortSize()]]
102		*/
103		public $tooBig;
104		/**
105		* @var string the error message used when the uploaded file is too small.
106		* You may use the following tokens in the message:
107		*
108		* - {attribute}: the attribute name
109		* - {file}: the uploaded file name
110		* - {limit}: the value of [[minSize]]
111		* - {formattedLimit}: the value of [[minSize]] formatted
112		* with [[\yii\i18n\Formatter::asShortSize()\|Formatter::asShortSize()]
113		*/
114		public $tooSmall;
115		/**
116		* @var string the error message used if the count of multiple uploads exceeds limit.
117		* You may use the following tokens in the message:
118		*
119		* - {attribute}: the attribute name
120		* - {limit}: the value of [[maxFiles]]
121		*/
122		public $tooMany;
123		/**
124		* @var string the error message used when the uploaded file has an extension name
125		* that is not listed in [[extensions]]. You may use the following tokens in the message:
126		*
127		* - {attribute}: the attribute name
128		* - {file}: the uploaded file name
129		* - {extensions}: the list of the allowed extensions.
130		*/
131		public $wrongExtension;
132		/**
133		* @var string the error message used when the file has an mime type
134		* that is not allowed by [[mimeTypes]] property.
135		* You may use the following tokens in the message:
136		*
137		* - {attribute}: the attribute name
138		* - {file}: the uploaded file name
139		* - {mimeTypes}: the value of [[mimeTypes]]
140		*/
141		public $wrongMimeType;
142
143
144		/**
145		* @inheritdoc
146		*/
147	21	public function init()
148		{
149	21	parent::init();
150	21	if ($this->message === null) {
151	21	$this->message = Yii::t('yii', 'File upload failed.');
152	21	}
153	21	if ($this->uploadRequired === null) {
154	21	$this->uploadRequired = Yii::t('yii', 'Please upload a file.');
155	21	}
156	21	if ($this->tooMany === null) {
157	21	$this->tooMany = Yii::t('yii', 'You can upload at most {limit, number} {limit, plural, one{file} other{files}}.');
158	21	}
159	21	if ($this->wrongExtension === null) {
160	21	$this->wrongExtension = Yii::t('yii', 'Only files with these extensions are allowed: {extensions}.');
161	21	}
162	21	if ($this->tooBig === null) {
163	21	$this->tooBig = Yii::t('yii', 'The file "{file}" is too big. Its size cannot exceed {formattedLimit}.');
164	21	}
165	21	if ($this->tooSmall === null) {
166	21	$this->tooSmall = Yii::t('yii', 'The file "{file}" is too small. Its size cannot be smaller than {formattedLimit}.');
167	21	}
168	21	if (!is_array($this->extensions)) {
169	21	$this->extensions = preg_split('/[\s,]+/', strtolower($this->extensions), -1, PREG_SPLIT_NO_EMPTY);
170	21	} else {
171	2	$this->extensions = array_map('strtolower', $this->extensions);
172		}
173	21	if ($this->wrongMimeType === null) {
174	21	$this->wrongMimeType = Yii::t('yii', 'Only files with these MIME types are allowed: {mimeTypes}.');
175	21	}
176	21	if (!is_array($this->mimeTypes)) {
177	21	$this->mimeTypes = preg_split('/[\s,]+/', strtolower($this->mimeTypes), -1, PREG_SPLIT_NO_EMPTY);
178	21	} else {
179	1	$this->mimeTypes = array_map('strtolower', $this->mimeTypes);
180		}
181	21	}
182
183		/**
184		* @inheritdoc
185		*/
186	7	public function validateAttribute($model, $attribute)
187		{
188	7	if ($this->maxFiles != 1) {
189	1	$files = $model->$attribute;
190	1	if (!is_array($files)) {
191	1	$this->addError($model, $attribute, $this->uploadRequired);
192
193	1	return;
194		}
195	1	foreach ($files as $i => $file) {
196	1	if (!$file instanceof UploadedFile \|\| $file->error == UPLOAD_ERR_NO_FILE) {
197	1	unset($files[$i]);
198	1	}
199	1	}
200	1	$model->$attribute = array_values($files);
201	1	if (empty($files)) {
202	1	$this->addError($model, $attribute, $this->uploadRequired);
203	1	}
204	1	if ($this->maxFiles && count($files) > $this->maxFiles) {
205	1	$this->addError($model, $attribute, $this->tooMany, ['limit' => $this->maxFiles]);
206	1	} else {
207	1	foreach ($files as $file) {
208	1	$result = $this->validateValue($file);
209	1	if (!empty($result)) {
210	1	$this->addError($model, $attribute, $result[0], $result[1]);
211	1	}
212	1	}
213		}
214	1	} else {
215	7	$result = $this->validateValue($model->$attribute);
216	7	if (!empty($result)) {
217	7	$this->addError($model, $attribute, $result[0], $result[1]);
218	7	}
219		}
220	7	}
221
222		/**
223		* @inheritdoc
224		*/
225	17	protected function validateValue($file)
226		{
227	17	if (!$file instanceof UploadedFile \|\| $file->error == UPLOAD_ERR_NO_FILE) {
228	1	return [$this->uploadRequired, []];
229		}
230
231	17	switch ($file->error) {
232	17	case UPLOAD_ERR_OK:
233	13	if ($this->maxSize !== null && $file->size > $this->getSizeLimit()) {
234		return [
235	1	$this->tooBig,
236		[
237	1	'file' => $file->name,
238	1	'limit' => $this->getSizeLimit(),
239	1	'formattedLimit' => Yii::$app->formatter->asShortSize($this->getSizeLimit())
240	1	]
241	1	];
242	13	} elseif ($this->minSize !== null && $file->size < $this->minSize) {
243		return [
244	1	$this->tooSmall,
245		[
246	1	'file' => $file->name,
247	1	'limit' => $this->minSize,
248	1	'formattedLimit' => Yii::$app->formatter->asShortSize($this->minSize)
249	1	]
250	1	];
251	13	} elseif (!empty($this->extensions) && !$this->validateExtension($file)) {
252	2	return [$this->wrongExtension, ['file' => $file->name, 'extensions' => implode(', ', $this->extensions)]];
253	13	} elseif (!empty($this->mimeTypes) && !$this->validateMimeType($file)) {
254	4	return [$this->wrongMimeType, ['file' => $file->name, 'mimeTypes' => implode(', ', $this->mimeTypes)]];
255		} else {
256	9	return null;
257		}
258	5	case UPLOAD_ERR_INI_SIZE:
259	5	case UPLOAD_ERR_FORM_SIZE:
260	1	return [$this->tooBig, [
261	1	'file' => $file->name,
262	1	'limit' => $this->getSizeLimit(),
263	1	'formattedLimit' => Yii::$app->formatter->asShortSize($this->getSizeLimit())
264	1	]];
265	5	case UPLOAD_ERR_PARTIAL:
266	2	Yii::warning('File was only partially uploaded: ' . $file->name, __METHOD__);
267	2	break;
268	3	case UPLOAD_ERR_NO_TMP_DIR:
269	1	Yii::warning('Missing the temporary folder to store the uploaded file: ' . $file->name, __METHOD__);
270	1	break;
271	2	case UPLOAD_ERR_CANT_WRITE:
272	1	Yii::warning('Failed to write the uploaded file to disk: ' . $file->name, __METHOD__);
273	1	break;
274	1	case UPLOAD_ERR_EXTENSION:
275	1	Yii::warning('File upload was stopped by some PHP extension: ' . $file->name, __METHOD__);
276	1	break;
277		default:
278		break;
279	5	}
280
281	5	return [$this->message, []];
282		}
283
284		/**
285		* Returns the maximum size allowed for uploaded files.
286		* This is determined based on four factors:
287		*
288		* - 'upload_max_filesize' in php.ini
289		* - 'post_max_size' in php.ini
290		* - 'MAX_FILE_SIZE' hidden field
291		* - [[maxSize]]
292		*
293		* @return integer the size limit for uploaded files.
294		*/
295	2	public function getSizeLimit()
296		{
297		// Get the lowest between post_max_size and upload_max_filesize, log a warning if the first is < than the latter
298	2	$limit = $this->sizeToBytes(ini_get('upload_max_filesize'));
299	2	$postLimit = $this->sizeToBytes(ini_get('post_max_size'));
300	2	if ($postLimit > 0 && $postLimit < $limit) {
301		Yii::warning('PHP.ini\'s \'post_max_size\' is less than \'upload_max_filesize\'.', __METHOD__);
302		$limit = $postLimit;
303		}
304	2	if ($this->maxSize !== null && $limit > 0 && $this->maxSize < $limit) {
305	2	$limit = $this->maxSize;
306	2	}
307	2	if (isset($_POST['MAX_FILE_SIZE']) && $_POST['MAX_FILE_SIZE'] > 0 && $_POST['MAX_FILE_SIZE'] < $limit) {
308	1	$limit = (int) $_POST['MAX_FILE_SIZE'];
309	1	}
310
311	2	return $limit;
312		}
313
314		/**
315		* @inheritdoc
316		*/
317	1	public function isEmpty($value, $trim = false)
		0 ignored issues – show Unused Code introduced 2015-11-20 21:52 UTC by Report Bug Copy Issue Report The parameter `$trim` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
318		{
319	1	$value = is_array($value) ? reset($value) : $value;
320	1	return !($value instanceof UploadedFile) \|\| $value->error == UPLOAD_ERR_NO_FILE;
321		}
322
323		/**
324		* Converts php.ini style size to bytes
325		*
326		* @param string $sizeStr $sizeStr
327		* @return integer
328		*/
329	2	private function sizeToBytes($sizeStr)
330		{
331	2	switch (substr($sizeStr, -1)) {
332	2	case 'M':
333	2	case 'm':
334	2	return (int) $sizeStr * 1048576;
335		case 'K':
336		case 'k':
337		return (int) $sizeStr * 1024;
338		case 'G':
339		case 'g':
340		return (int) $sizeStr * 1073741824;
341		default:
342		return (int) $sizeStr;
343		}
344		}
345
346		/**
347		* Checks if given uploaded file have correct type (extension) according current validator settings.
348		* @param UploadedFile $file
349		* @return boolean
350		*/
351	2	protected function validateExtension($file)
352		{
353	2	$extension = mb_strtolower($file->extension, 'UTF-8');
354
355	2	if ($this->checkExtensionByMimeType) {
356
357		$mimeType = FileHelper::getMimeType($file->tempName, null, false);
358		if ($mimeType === null) {
359		return false;
360		}
361
362		$extensionsByMimeType = FileHelper::getExtensionsByMimeType($mimeType);
363
364		if (!in_array($extension, $extensionsByMimeType, true)) {
365		return false;
366		}
367		}
368
369	2	if (!in_array($extension, $this->extensions, true)) {
370	2	return false;
371		}
372
373	2	return true;
374		}
375
376		/**
377		* @inheritdoc
378		*/
379		public function clientValidateAttribute($model, $attribute, $view)
380		{
381		ValidationAsset::register($view);
382		$options = $this->getClientOptions($model, $attribute);
383		return 'yii.validation.file(attribute, messages, ' . Json::encode($options) . ');';
384		}
385
386		/**
387		* Returns the client side validation options.
388		* @param \yii\base\Model $model the model being validated
389		* @param string $attribute the attribute name being validated
390		* @return array the client side validation options
391		*/
392		protected function getClientOptions($model, $attribute)
393		{
394		$label = $model->getAttributeLabel($attribute);
395
396		$options = [];
397		if ($this->message !== null) {
398		$options['message'] = Yii::$app->getI18n()->format($this->message, [
399		'attribute' => $label,
400		], Yii::$app->language);
401		}
402
403		$options['skipOnEmpty'] = $this->skipOnEmpty;
404
405		if (!$this->skipOnEmpty) {
406		$options['uploadRequired'] = Yii::$app->getI18n()->format($this->uploadRequired, [
407		'attribute' => $label,
408		], Yii::$app->language);
409		}
410
411		if ($this->mimeTypes !== null) {
412		$mimeTypes = [];
413		foreach ($this->mimeTypes as $mimeType) {
		0 ignored issues – show Bug introduced 2015-12-15 06:26 UTC by Report Bug Copy Issue Report The expression `$this->mimeTypes` of type `array\|string` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
414		$mimeTypes[] = new JsExpression(Html::escapeJsRegularExpression($this->buildMimeTypeRegexp($mimeType)));
415		}
416		$options['mimeTypes'] = $mimeTypes;
417		$options['wrongMimeType'] = Yii::$app->getI18n()->format($this->wrongMimeType, [
418		'attribute' => $label,
419		'mimeTypes' => implode(', ', $this->mimeTypes),
420		], Yii::$app->language);
421		}
422
423		if ($this->extensions !== null) {
424		$options['extensions'] = $this->extensions;
425		$options['wrongExtension'] = Yii::$app->getI18n()->format($this->wrongExtension, [
426		'attribute' => $label,
427		'extensions' => implode(', ', $this->extensions),
428		], Yii::$app->language);
429		}
430
431		if ($this->minSize !== null) {
432		$options['minSize'] = $this->minSize;
433		$options['tooSmall'] = Yii::$app->getI18n()->format($this->tooSmall, [
434		'attribute' => $label,
435		'limit' => $this->minSize,
436		'formattedLimit' => Yii::$app->formatter->asShortSize($this->minSize),
437		], Yii::$app->language);
438		}
439
440		if ($this->maxSize !== null) {
441		$options['maxSize'] = $this->maxSize;
442		$options['tooBig'] = Yii::$app->getI18n()->format($this->tooBig, [
443		'attribute' => $label,
444		'limit' => $this->getSizeLimit(),
445		'formattedLimit' => Yii::$app->formatter->asShortSize($this->getSizeLimit()),
446		], Yii::$app->language);
447		}
448
449		if ($this->maxFiles !== null) {
450		$options['maxFiles'] = $this->maxFiles;
451		$options['tooMany'] = Yii::$app->getI18n()->format($this->tooMany, [
452		'attribute' => $label,
453		'limit' => $this->maxFiles,
454		], Yii::$app->language);
455		}
456
457		return $options;
458		}
459
460		/**
461		* Builds the RegExp from the $mask
462		*
463		* @param string $mask
464		* @return string the regular expression
465		* @see mimeTypes
466		*/
467	9	private function buildMimeTypeRegexp($mask)
468		{
469	9	return '/^' . str_replace('\', '.', preg_quote($mask, '/')) . '$/';
470		}
471
472		/**
473		* Checks the mimeType of the $file against the list in the [[mimeTypes]] property
474		*
475		* @param UploadedFile $file
476		* @return boolean whether the $file mimeType is allowed
477		* @throws \yii\base\InvalidConfigException
478		* @see mimeTypes
479		* @since 2.0.8
480		*/
481	10	protected function validateMimeType($file)
482		{
483	10	$fileMimeType = FileHelper::getMimeType($file->tempName);
484
485	10	foreach ($this->mimeTypes as $mimeType) {
		0 ignored issues – show Bug introduced 2016-02-24 06:38 UTC by Report Bug Copy Issue Report The expression `$this->mimeTypes` of type `array\|string` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
486	10	if ($mimeType === $fileMimeType) {
487		return true;
488		}
489
490	10	if (strpos($mimeType, '*') !== false && preg_match($this->buildMimeTypeRegexp($mimeType), $fileMimeType)) {
491	6	return true;
492		}
493	4	}
494
495	4	return false;
496		}
497		}
498

yiisoft / yii2

Push — 11139-each-validator-attribute... ( a0e614 )

FileValidator::validateExtension() B

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like