rob006 /
yii2-dev
| Total Complexity | 88 |
| Total Lines | 516 |
| Duplicated Lines | 0 % |
| Coverage | 65% |
| Changes | 1 | ||
| Bugs | 0 | Features | 0 |
Complex classes like FileValidator often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use FileValidator, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 28 | class FileValidator extends Validator |
||
| 29 | { |
||
| 30 | /** |
||
| 31 | * @var array|string|null a list of file name extensions that are allowed to be uploaded. |
||
| 32 | * This can be either an array or a string consisting of file extension names |
||
| 33 | * separated by space or comma (e.g. "gif, jpg"). |
||
| 34 | * Extension names are case-insensitive. Defaults to null, meaning all file name |
||
| 35 | * extensions are allowed. |
||
| 36 | * @see wrongExtension for the customized message for wrong file type. |
||
| 37 | */ |
||
| 38 | public $extensions; |
||
| 39 | /** |
||
| 40 | * @var bool whether to check file type (extension) with mime-type. If extension produced by |
||
| 41 | * file mime-type check differs from uploaded file extension, the file will be considered as invalid. |
||
| 42 | */ |
||
| 43 | public $checkExtensionByMimeType = true; |
||
| 44 | /** |
||
| 45 | * @var array|string|null a list of file MIME types that are allowed to be uploaded. |
||
| 46 | * This can be either an array or a string consisting of file MIME types |
||
| 47 | * separated by space or comma (e.g. "text/plain, image/png"). |
||
| 48 | * The mask with the special character `*` can be used to match groups of mime types. |
||
| 49 | * For example `image/*` will pass all mime types, that begin with `image/` (e.g. `image/jpeg`, `image/png`). |
||
| 50 | * Mime type names are case-insensitive. Defaults to null, meaning all MIME types are allowed. |
||
| 51 | * @see wrongMimeType for the customized message for wrong MIME type. |
||
| 52 | */ |
||
| 53 | public $mimeTypes; |
||
| 54 | /** |
||
| 55 | * @var int|null the minimum number of bytes required for the uploaded file. |
||
| 56 | * Defaults to null, meaning no limit. |
||
| 57 | * @see tooSmall for the customized message for a file that is too small. |
||
| 58 | */ |
||
| 59 | public $minSize; |
||
| 60 | /** |
||
| 61 | * @var int|null the maximum number of bytes required for the uploaded file. |
||
| 62 | * Defaults to null, meaning no limit. |
||
| 63 | * Note, the size limit is also affected by `upload_max_filesize` and `post_max_size` INI setting |
||
| 64 | * and the 'MAX_FILE_SIZE' hidden field value. See [[getSizeLimit()]] for details. |
||
| 65 | * @see https://www.php.net/manual/en/ini.core.php#ini.upload-max-filesize |
||
| 66 | * @see https://www.php.net/post-max-size |
||
| 67 | * @see getSizeLimit |
||
| 68 | * @see tooBig for the customized message for a file that is too big. |
||
| 69 | */ |
||
| 70 | public $maxSize; |
||
| 71 | /** |
||
| 72 | * @var int the maximum file count the given attribute can hold. |
||
| 73 | * Defaults to 1, meaning single file upload. By defining a higher number, |
||
| 74 | * multiple uploads become possible. Setting it to `0` means there is no limit on |
||
| 75 | * the number of files that can be uploaded simultaneously. |
||
| 76 | * |
||
| 77 | * > Note: The maximum number of files allowed to be uploaded simultaneously is |
||
| 78 | * also limited with PHP directive `max_file_uploads`, which defaults to 20. |
||
| 79 | * |
||
| 80 | * @see https://www.php.net/manual/en/ini.core.php#ini.max-file-uploads |
||
| 81 | * @see tooMany for the customized message when too many files are uploaded. |
||
| 82 | */ |
||
| 83 | public $maxFiles = 1; |
||
| 84 | /** |
||
| 85 | * @var int the minimum file count the given attribute can hold. |
||
| 86 | * Defaults to 0. Higher value means at least that number of files should be uploaded. |
||
| 87 | * |
||
| 88 | * @see tooFew for the customized message when too few files are uploaded. |
||
| 89 | * @since 2.0.14 |
||
| 90 | */ |
||
| 91 | public $minFiles = 0; |
||
| 92 | /** |
||
| 93 | * @var string the error message used when a file is not uploaded correctly. |
||
| 94 | */ |
||
| 95 | public $message; |
||
| 96 | /** |
||
| 97 | * @var string the error message used when no file is uploaded. |
||
| 98 | * Note that this is the text of the validation error message. To make uploading files required, |
||
| 99 | * you have to set [[skipOnEmpty]] to `false`. |
||
| 100 | */ |
||
| 101 | public $uploadRequired; |
||
| 102 | /** |
||
| 103 | * @var string the error message used when the uploaded file is too large. |
||
| 104 | * You may use the following tokens in the message: |
||
| 105 | * |
||
| 106 | * - {attribute}: the attribute name |
||
| 107 | * - {file}: the uploaded file name |
||
| 108 | * - {limit}: the maximum size allowed (see [[getSizeLimit()]]) |
||
| 109 | * - {formattedLimit}: the maximum size formatted |
||
| 110 | * with [[\yii\i18n\Formatter::asShortSize()|Formatter::asShortSize()]] |
||
| 111 | */ |
||
| 112 | public $tooBig; |
||
| 113 | /** |
||
| 114 | * @var string the error message used when the uploaded file is too small. |
||
| 115 | * You may use the following tokens in the message: |
||
| 116 | * |
||
| 117 | * - {attribute}: the attribute name |
||
| 118 | * - {file}: the uploaded file name |
||
| 119 | * - {limit}: the value of [[minSize]] |
||
| 120 | * - {formattedLimit}: the value of [[minSize]] formatted |
||
| 121 | * with [[\yii\i18n\Formatter::asShortSize()|Formatter::asShortSize()] |
||
| 122 | */ |
||
| 123 | public $tooSmall; |
||
| 124 | /** |
||
| 125 | * @var string the error message used if the count of multiple uploads exceeds limit. |
||
| 126 | * You may use the following tokens in the message: |
||
| 127 | * |
||
| 128 | * - {attribute}: the attribute name |
||
| 129 | * - {limit}: the value of [[maxFiles]] |
||
| 130 | */ |
||
| 131 | public $tooMany; |
||
| 132 | /** |
||
| 133 | * @var string the error message used if the count of multiple uploads less that minFiles. |
||
| 134 | * You may use the following tokens in the message: |
||
| 135 | * |
||
| 136 | * - {attribute}: the attribute name |
||
| 137 | * - {limit}: the value of [[minFiles]] |
||
| 138 | * |
||
| 139 | * @since 2.0.14 |
||
| 140 | */ |
||
| 141 | public $tooFew; |
||
| 142 | /** |
||
| 143 | * @var string the error message used when the uploaded file has an extension name |
||
| 144 | * that is not listed in [[extensions]]. You may use the following tokens in the message: |
||
| 145 | * |
||
| 146 | * - {attribute}: the attribute name |
||
| 147 | * - {file}: the uploaded file name |
||
| 148 | * - {extensions}: the list of the allowed extensions. |
||
| 149 | */ |
||
| 150 | public $wrongExtension; |
||
| 151 | /** |
||
| 152 | * @var string the error message used when the file has an mime type |
||
| 153 | * that is not allowed by [[mimeTypes]] property. |
||
| 154 | * You may use the following tokens in the message: |
||
| 155 | * |
||
| 156 | * - {attribute}: the attribute name |
||
| 157 | * - {file}: the uploaded file name |
||
| 158 | * - {mimeTypes}: the value of [[mimeTypes]] |
||
| 159 | */ |
||
| 160 | public $wrongMimeType; |
||
| 161 | |||
| 162 | |||
| 163 | /** |
||
| 164 | * {@inheritdoc} |
||
| 165 | */ |
||
| 166 | 53 | public function init() |
|
| 202 | } |
||
| 203 | } |
||
| 204 | |||
| 205 | /** |
||
| 206 | * {@inheritdoc} |
||
| 207 | */ |
||
| 208 | 18 | public function validateAttribute($model, $attribute) |
|
| 209 | { |
||
| 210 | 18 | $files = $this->filterFiles(is_array($model->$attribute) ? $model->$attribute : [$model->$attribute]); |
|
| 211 | 18 | $filesCount = count($files); |
|
| 212 | 18 | if ($filesCount === 0 && $this->minFiles > 0) { |
|
| 213 | $this->addError($model, $attribute, $this->uploadRequired); |
||
| 214 | |||
| 215 | return; |
||
| 216 | } |
||
| 217 | |||
| 218 | 18 | if ($this->maxFiles > 0 && $filesCount > $this->maxFiles) { |
|
| 219 | 2 | $this->addError($model, $attribute, $this->tooMany, ['limit' => $this->maxFiles]); |
|
| 220 | } |
||
| 221 | 18 | if ($this->minFiles > 0 && $this->minFiles > $filesCount) { |
|
| 222 | 2 | $this->addError($model, $attribute, $this->tooFew, ['limit' => $this->minFiles]); |
|
| 223 | } |
||
| 224 | |||
| 225 | 18 | foreach ($files as $file) { |
|
| 226 | 18 | $result = $this->validateValue($file); |
|
| 227 | 18 | if (!empty($result)) { |
|
| 228 | 8 | $this->addError($model, $attribute, $result[0], $result[1]); |
|
| 229 | } |
||
| 230 | } |
||
| 231 | } |
||
| 232 | |||
| 233 | /** |
||
| 234 | * Files filter. |
||
| 235 | * @param array $files |
||
| 236 | * @return UploadedFile[] |
||
| 237 | */ |
||
| 238 | 18 | private function filterFiles(array $files) |
|
| 239 | { |
||
| 240 | 18 | $result = []; |
|
| 241 | |||
| 242 | 18 | foreach ($files as $fileName => $file) { |
|
| 243 | 18 | if ($file instanceof UploadedFile && $file->error !== UPLOAD_ERR_NO_FILE) { |
|
| 244 | 18 | $result[$fileName] = $file; |
|
| 245 | } |
||
| 246 | } |
||
| 247 | |||
| 248 | 18 | return $result; |
|
| 249 | } |
||
| 250 | |||
| 251 | /** |
||
| 252 | * {@inheritdoc} |
||
| 253 | */ |
||
| 254 | 48 | protected function validateValue($value) |
|
| 255 | { |
||
| 256 | 48 | if (!$value instanceof UploadedFile || $value->error == UPLOAD_ERR_NO_FILE) { |
|
| 257 | return [$this->uploadRequired, []]; |
||
| 258 | } |
||
| 259 | |||
| 260 | 48 | switch ($value->error) { |
|
| 261 | 48 | case UPLOAD_ERR_OK: |
|
| 262 | 44 | if ($this->maxSize !== null && $value->size > $this->getSizeLimit()) { |
|
| 263 | 1 | return [ |
|
| 264 | 1 | $this->tooBig, |
|
| 265 | 1 | [ |
|
| 266 | 1 | 'file' => $value->name, |
|
| 267 | 1 | 'limit' => $this->getSizeLimit(), |
|
| 268 | 1 | 'formattedLimit' => Yii::$app->formatter->asShortSize($this->getSizeLimit()), |
|
| 269 | 1 | ], |
|
| 270 | 1 | ]; |
|
| 271 | 44 | } elseif ($this->minSize !== null && $value->size < $this->minSize) { |
|
| 272 | 1 | return [ |
|
| 273 | 1 | $this->tooSmall, |
|
| 274 | 1 | [ |
|
| 275 | 1 | 'file' => $value->name, |
|
| 276 | 1 | 'limit' => $this->minSize, |
|
| 277 | 1 | 'formattedLimit' => Yii::$app->formatter->asShortSize($this->minSize), |
|
| 278 | 1 | ], |
|
| 279 | 1 | ]; |
|
| 280 | 44 | } elseif (!empty($this->extensions) && !$this->validateExtension($value)) { |
|
| 281 | 8 | return [$this->wrongExtension, ['file' => $value->name, 'extensions' => implode(', ', $this->extensions)]]; |
|
| 282 | 39 | } elseif (!empty($this->mimeTypes) && !$this->validateMimeType($value)) { |
|
| 283 | 5 | return [$this->wrongMimeType, ['file' => $value->name, 'mimeTypes' => implode(', ', $this->mimeTypes)]]; |
|
|
Bug
introduced
by
|
|||
| 284 | } |
||
| 285 | |||
| 286 | 34 | return null; |
|
| 287 | 5 | case UPLOAD_ERR_INI_SIZE: |
|
| 288 | 5 | case UPLOAD_ERR_FORM_SIZE: |
|
| 289 | 1 | return [$this->tooBig, [ |
|
| 290 | 1 | 'file' => $value->name, |
|
| 291 | 1 | 'limit' => $this->getSizeLimit(), |
|
| 292 | 1 | 'formattedLimit' => Yii::$app->formatter->asShortSize($this->getSizeLimit()), |
|
| 293 | 1 | ]]; |
|
| 294 | 5 | case UPLOAD_ERR_PARTIAL: |
|
| 295 | 2 | Yii::warning('File was only partially uploaded: ' . $value->name, __METHOD__); |
|
| 296 | 2 | break; |
|
| 297 | 3 | case UPLOAD_ERR_NO_TMP_DIR: |
|
| 298 | 1 | Yii::warning('Missing the temporary folder to store the uploaded file: ' . $value->name, __METHOD__); |
|
| 299 | 1 | break; |
|
| 300 | 2 | case UPLOAD_ERR_CANT_WRITE: |
|
| 301 | 1 | Yii::warning('Failed to write the uploaded file to disk: ' . $value->name, __METHOD__); |
|
| 302 | 1 | break; |
|
| 303 | 1 | case UPLOAD_ERR_EXTENSION: |
|
| 304 | 1 | Yii::warning('File upload was stopped by some PHP extension: ' . $value->name, __METHOD__); |
|
| 305 | 1 | break; |
|
| 306 | default: |
||
| 307 | break; |
||
| 308 | } |
||
| 309 | |||
| 310 | 5 | return [$this->message, []]; |
|
| 311 | } |
||
| 312 | |||
| 313 | /** |
||
| 314 | * Returns the maximum size allowed for uploaded files. |
||
| 315 | * |
||
| 316 | * This is determined based on four factors: |
||
| 317 | * |
||
| 318 | * - 'upload_max_filesize' in php.ini |
||
| 319 | * - 'post_max_size' in php.ini |
||
| 320 | * - 'MAX_FILE_SIZE' hidden field |
||
| 321 | * - [[maxSize]] |
||
| 322 | * |
||
| 323 | * @return int the size limit for uploaded files. |
||
| 324 | */ |
||
| 325 | 2 | public function getSizeLimit() |
|
| 342 | } |
||
| 343 | |||
| 344 | /** |
||
| 345 | * {@inheritdoc} |
||
| 346 | * @param bool $trim |
||
| 347 | */ |
||
| 348 | 1 | public function isEmpty($value, $trim = false) |
|
| 349 | { |
||
| 350 | 1 | $value = is_array($value) ? reset($value) : $value; |
|
| 351 | 1 | return !($value instanceof UploadedFile) || $value->error == UPLOAD_ERR_NO_FILE; |
|
| 352 | } |
||
| 353 | |||
| 354 | /** |
||
| 355 | * Converts php.ini style size to bytes. |
||
| 356 | * |
||
| 357 | * @param string $sizeStr $sizeStr |
||
| 358 | * @return int |
||
| 359 | */ |
||
| 360 | 2 | private function sizeToBytes($sizeStr) |
|
| 361 | { |
||
| 362 | 2 | switch (substr($sizeStr, -1)) { |
|
| 363 | 2 | case 'M': |
|
| 364 | case 'm': |
||
| 365 | 2 | return (int) $sizeStr * 1048576; |
|
| 366 | case 'K': |
||
| 367 | case 'k': |
||
| 368 | return (int) $sizeStr * 1024; |
||
| 369 | case 'G': |
||
| 370 | case 'g': |
||
| 371 | return (int) $sizeStr * 1073741824; |
||
| 372 | default: |
||
| 373 | return (int) $sizeStr; |
||
| 374 | } |
||
| 375 | } |
||
| 376 | |||
| 377 | /** |
||
| 378 | * Checks if given uploaded file have correct type (extension) according current validator settings. |
||
| 379 | * @param UploadedFile $file |
||
| 380 | * @return bool |
||
| 381 | */ |
||
| 382 | 17 | protected function validateExtension($file) |
|
| 383 | { |
||
| 384 | 17 | $extension = mb_strtolower($file->extension, 'UTF-8'); |
|
| 385 | |||
| 386 | 17 | if ($this->checkExtensionByMimeType) { |
|
| 387 | 13 | $mimeType = FileHelper::getMimeType($file->tempName, null, false); |
|
| 388 | 13 | if ($mimeType === null) { |
|
| 389 | return false; |
||
| 390 | } |
||
| 391 | |||
| 392 | 13 | $extensionsByMimeType = FileHelper::getExtensionsByMimeType($mimeType); |
|
| 393 | |||
| 394 | 13 | if (!in_array($extension, $extensionsByMimeType, true)) { |
|
| 395 | return false; |
||
| 396 | } |
||
| 397 | } |
||
| 398 | |||
| 399 | 17 | if (!empty($this->extensions)) { |
|
| 400 | 17 | foreach ((array) $this->extensions as $ext) { |
|
| 401 | 17 | if ($extension === $ext || StringHelper::endsWith($file->name, ".$ext", false)) { |
|
| 402 | 12 | return true; |
|
| 403 | } |
||
| 404 | } |
||
| 405 | 8 | return false; |
|
| 406 | } |
||
| 407 | |||
| 408 | return true; |
||
| 409 | } |
||
| 410 | |||
| 411 | /** |
||
| 412 | * {@inheritdoc} |
||
| 413 | */ |
||
| 414 | public function clientValidateAttribute($model, $attribute, $view) |
||
| 415 | { |
||
| 416 | ValidationAsset::register($view); |
||
| 417 | $options = $this->getClientOptions($model, $attribute); |
||
| 418 | return 'yii.validation.file(attribute, messages, ' . Json::htmlEncode($options) . ');'; |
||
| 419 | } |
||
| 420 | |||
| 421 | /** |
||
| 422 | * {@inheritdoc} |
||
| 423 | */ |
||
| 424 | public function getClientOptions($model, $attribute) |
||
| 425 | { |
||
| 426 | $label = $model->getAttributeLabel($attribute); |
||
| 427 | |||
| 428 | $options = []; |
||
| 429 | if ($this->message !== null) { |
||
| 430 | $options['message'] = $this->formatMessage($this->message, [ |
||
| 431 | 'attribute' => $label, |
||
| 432 | ]); |
||
| 433 | } |
||
| 434 | |||
| 435 | $options['skipOnEmpty'] = $this->skipOnEmpty; |
||
| 436 | |||
| 437 | if (!$this->skipOnEmpty) { |
||
| 438 | $options['uploadRequired'] = $this->formatMessage($this->uploadRequired, [ |
||
| 439 | 'attribute' => $label, |
||
| 440 | ]); |
||
| 441 | } |
||
| 442 | |||
| 443 | if ($this->mimeTypes !== null) { |
||
| 444 | $mimeTypes = []; |
||
| 445 | foreach ($this->mimeTypes as $mimeType) { |
||
| 446 | $mimeTypes[] = new JsExpression(Html::escapeJsRegularExpression($this->buildMimeTypeRegexp($mimeType))); |
||
| 447 | } |
||
| 448 | $options['mimeTypes'] = $mimeTypes; |
||
| 449 | $options['wrongMimeType'] = $this->formatMessage($this->wrongMimeType, [ |
||
| 450 | 'attribute' => $label, |
||
| 451 | 'mimeTypes' => implode(', ', $this->mimeTypes), |
||
| 452 | ]); |
||
| 453 | } |
||
| 454 | |||
| 455 | if ($this->extensions !== null) { |
||
| 456 | $options['extensions'] = $this->extensions; |
||
| 457 | $options['wrongExtension'] = $this->formatMessage($this->wrongExtension, [ |
||
| 458 | 'attribute' => $label, |
||
| 459 | 'extensions' => implode(', ', $this->extensions), |
||
| 460 | ]); |
||
| 461 | } |
||
| 462 | |||
| 463 | if ($this->minSize !== null) { |
||
| 464 | $options['minSize'] = $this->minSize; |
||
| 465 | $options['tooSmall'] = $this->formatMessage($this->tooSmall, [ |
||
| 466 | 'attribute' => $label, |
||
| 467 | 'limit' => $this->minSize, |
||
| 468 | 'formattedLimit' => Yii::$app->formatter->asShortSize($this->minSize), |
||
| 469 | ]); |
||
| 470 | } |
||
| 471 | |||
| 472 | if ($this->maxSize !== null) { |
||
| 473 | $options['maxSize'] = $this->maxSize; |
||
| 474 | $options['tooBig'] = $this->formatMessage($this->tooBig, [ |
||
| 475 | 'attribute' => $label, |
||
| 476 | 'limit' => $this->getSizeLimit(), |
||
| 477 | 'formattedLimit' => Yii::$app->formatter->asShortSize($this->getSizeLimit()), |
||
| 478 | ]); |
||
| 479 | } |
||
| 480 | |||
| 481 | if ($this->maxFiles !== null) { |
||
| 482 | $options['maxFiles'] = $this->maxFiles; |
||
| 483 | $options['tooMany'] = $this->formatMessage($this->tooMany, [ |
||
| 484 | 'attribute' => $label, |
||
| 485 | 'limit' => $this->maxFiles, |
||
| 486 | ]); |
||
| 487 | } |
||
| 488 | |||
| 489 | return $options; |
||
| 490 | } |
||
| 491 | |||
| 492 | /** |
||
| 493 | * Builds the RegExp from the $mask. |
||
| 494 | * |
||
| 495 | * @param string $mask |
||
| 496 | * @return string the regular expression |
||
| 497 | * @see mimeTypes |
||
| 498 | */ |
||
| 499 | 13 | private function buildMimeTypeRegexp($mask) |
|
| 500 | { |
||
| 501 | 13 | return '/^' . str_replace('\*', '.*', preg_quote($mask, '/')) . '$/i'; |
|
| 502 | } |
||
| 503 | |||
| 504 | /** |
||
| 505 | * Checks the mimeType of the $file against the list in the [[mimeTypes]] property. |
||
| 506 | * |
||
| 507 | * @param UploadedFile $file |
||
| 508 | * @return bool whether the $file mimeType is allowed |
||
| 509 | * @throws \yii\base\InvalidConfigException |
||
| 510 | * @see mimeTypes |
||
| 511 | * @since 2.0.8 |
||
| 512 | */ |
||
| 513 | 17 | protected function validateMimeType($file) |
|
| 531 | } |
||
| 532 | |||
| 533 | /** |
||
| 534 | * Get MIME type by file path |
||
| 535 | * |
||
| 536 | * @param string $filePath |
||
| 537 | * @return string|null |
||
| 538 | * @throws \yii\base\InvalidConfigException |
||
| 539 | * @since 2.0.26 |
||
| 540 | */ |
||
| 541 | 13 | protected function getMimeTypeByFile($filePath) |
|
| 544 | } |
||
| 545 | } |
||
| 546 |
Loading history...
