Class yii\validators\FileValidator

 public function __call($name, $params)
{
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $object) {
 if ($object->hasMethod($name)) {
 return call_user_func_array([$object, $name], $params);
 }
 }
 throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

 

 public function __clone()
{
 $this->_events = [];
 $this->_eventWildcards = [];
 $this->_behaviors = null;
}

 

 public function __construct($config = [])
{
 if (!empty($config)) {
 Yii::configure($this, $config);
 }
 $this->init();
}

 

 public function __get($name)
{
 $getter = 'get' . $name;
 if (method_exists($this, $getter)) {
 // read property, e.g. getName()
 return $this->$getter();
 }
 // behavior property
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canGetProperty($name)) {
 return $behavior->$name;
 }
 }
 if (method_exists($this, 'set' . $name)) {
 throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
 }
 throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

 

 public function __isset($name)
{
 $getter = 'get' . $name;
 if (method_exists($this, $getter)) {
 return $this->$getter() !== null;
 }
 // behavior property
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canGetProperty($name)) {
 return $behavior->$name !== null;
 }
 }
 return false;
}

 

 public function __set($name, $value)
{
 $setter = 'set' . $name;
 if (method_exists($this, $setter)) {
 // set property
 $this->$setter($value);
 return;
 } elseif (strncmp($name, 'on ', 3) === 0) {
 // on event: attach event handler
 $this->on(trim(substr($name, 3)), $value);
 return;
 } elseif (strncmp($name, 'as ', 3) === 0) {
 // as behavior: attach behavior
 $name = trim(substr($name, 3));
 if ($value instanceof Behavior) {
 $this->attachBehavior($name, $value);
 } elseif ($value instanceof \Closure) {
 $this->attachBehavior($name, call_user_func($value));
 } elseif (isset($value['__class']) && is_subclass_of($value['__class'], Behavior::class)) {
 $this->attachBehavior($name, Yii::createObject($value));
 } elseif (!isset($value['__class']) && isset($value['class']) && is_subclass_of($value['class'], Behavior::class)) {
 $this->attachBehavior($name, Yii::createObject($value));
 } elseif (is_string($value) && is_subclass_of($value, Behavior::class, true)) {
 $this->attachBehavior($name, Yii::createObject($value));
 } else {
 throw new InvalidConfigException('Class is not of type ' . Behavior::class . ' or its subclasses');
 }
 return;
 }
 // behavior property
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canSetProperty($name)) {
 $behavior->$name = $value;
 return;
 }
 }
 if (method_exists($this, 'get' . $name)) {
 throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
 }
 throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

 

 public function __unset($name)
{
 $setter = 'set' . $name;
 if (method_exists($this, $setter)) {
 $this->$setter(null);
 return;
 }
 // behavior property
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canSetProperty($name)) {
 $behavior->$name = null;
 return;
 }
 }
 throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

 

 public function addError($model, $attribute, $message, $params = [])
{
 $params['attribute'] = $model->getAttributeLabel($attribute);
 if (!isset($params['value'])) {
 $value = $model->$attribute;
 if (is_array($value)) {
 $params['value'] = 'array()';
 } elseif (is_object($value) && !method_exists($value, '__toString')) {
 $params['value'] = '(object)';
 } else {
 $params['value'] = $value;
 }
 }
 $model->addError($attribute, $this->formatMessage($message, $params));
}

 

 public function attachBehavior($name, $behavior)
{
 $this->ensureBehaviors();
 return $this->attachBehaviorInternal($name, $behavior);
}

 

 public function attachBehaviors($behaviors)
{
 $this->ensureBehaviors();
 foreach ($behaviors as $name => $behavior) {
 $this->attachBehaviorInternal($name, $behavior);
 }
}

 

 public function behaviors()
{
 return [];
}

 

 public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
 if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
 return true;
 } elseif ($checkBehaviors) {
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canGetProperty($name, $checkVars)) {
 return true;
 }
 }
 }
 return false;
}

 

 public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
 if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
 return true;
 } elseif ($checkBehaviors) {
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->canSetProperty($name, $checkVars)) {
 return true;
 }
 }
 }
 return false;
}

 

 public static function className()
{
 return get_called_class();
}

 

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

 

 public static function createValidator($type, $model, $attributes, $params = [])
{
 $params['attributes'] = $attributes;
 if ($type instanceof \Closure) {
 $params['class'] = __NAMESPACE__ . '\InlineValidator';
 $params['method'] = $type;
 } elseif (!isset(static::$builtInValidators[$type]) && $model->hasMethod($type)) {
 // method-based validator
 $params['class'] = __NAMESPACE__ . '\InlineValidator';
 $params['method'] = [$model, $type];
 } else {
 unset($params['current']);
 if (isset(static::$builtInValidators[$type])) {
 $type = static::$builtInValidators[$type];
 }
 if (is_array($type)) {
 $params = array_merge($type, $params);
 } else {
 $params['class'] = $type;
 }
 }
 return Yii::createObject($params);
}

 

 public function detachBehavior($name)
{
 $this->ensureBehaviors();
 if (isset($this->_behaviors[$name])) {
 $behavior = $this->_behaviors[$name];
 unset($this->_behaviors[$name]);
 $behavior->detach();
 return $behavior;
 }
 return null;
}

 

 public function detachBehaviors()
{
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $name => $behavior) {
 $this->detachBehavior($name);
 }
}

 

 public function ensureBehaviors()
{
 if ($this->_behaviors === null) {
 $this->_behaviors = [];
 foreach ($this->behaviors() as $name => $behavior) {
 $this->attachBehaviorInternal($name, $behavior);
 }
 }
}

 

 protected function formatMessage($message, $params)
{
 if (Yii::$app !== null) {
 return \Yii::$app->getI18n()->format($message, $params, Yii::$app->language);
 }
 $placeholders = [];
 foreach ((array) $params as $name => $value) {
 $placeholders['{' . $name . '}'] = $value;
 }
 return ($placeholders === []) ? $message : strtr($message, $placeholders);
}

 

 public function getAttributeNames()
{
 return array_map(function ($attribute) {
 return ltrim($attribute, '!');
 }, $this->attributes);
}

 

 public function getBehavior($name)
{
 $this->ensureBehaviors();
 return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

 

 public function getBehaviors()
{
 $this->ensureBehaviors();
 return $this->_behaviors;
}

 

 public function getClientOptions($model, $attribute)
{
 $label = $model->getAttributeLabel($attribute);
 $options = [];
 if ($this->message !== null) {
 $options['message'] = $this->formatMessage($this->message, [
 'attribute' => $label,
 ]);
 }
 $options['skipOnEmpty'] = $this->skipOnEmpty;
 if (!$this->skipOnEmpty) {
 $options['uploadRequired'] = $this->formatMessage($this->uploadRequired, [
 'attribute' => $label,
 ]);
 }
 if ($this->mimeTypes !== null) {
 $mimeTypes = [];
 foreach ($this->mimeTypes as $mimeType) {
 $mimeTypes[] = new JsExpression(Html::escapeJsRegularExpression($this->buildMimeTypeRegexp($mimeType)));
 }
 $options['mimeTypes'] = $mimeTypes;
 $options['wrongMimeType'] = $this->formatMessage($this->wrongMimeType, [
 'attribute' => $label,
 'mimeTypes' => implode(', ', $this->mimeTypes),
 ]);
 }
 if ($this->extensions !== null) {
 $options['extensions'] = $this->extensions;
 $options['wrongExtension'] = $this->formatMessage($this->wrongExtension, [
 'attribute' => $label,
 'extensions' => implode(', ', $this->extensions),
 ]);
 }
 if ($this->minSize !== null) {
 $options['minSize'] = $this->minSize;
 $options['tooSmall'] = $this->formatMessage($this->tooSmall, [
 'attribute' => $label,
 'limit' => $this->minSize,
 'formattedLimit' => Yii::$app->formatter->asShortSize($this->minSize),
 ]);
 }
 if ($this->maxSize !== null) {
 $options['maxSize'] = $this->maxSize;
 $options['tooBig'] = $this->formatMessage($this->tooBig, [
 'attribute' => $label,
 'limit' => $this->getSizeLimit(),
 'formattedLimit' => Yii::$app->formatter->asShortSize($this->getSizeLimit()),
 ]);
 }
 if ($this->maxFiles !== null) {
 $options['maxFiles'] = $this->maxFiles;
 $options['tooMany'] = $this->formatMessage($this->tooMany, [
 'attribute' => $label,
 'limit' => $this->maxFiles,
 ]);
 }
 return $options;
}

 

 protected function getMimeTypeByFile($filePath)
{
 return FileHelper::getMimeType($filePath);
}

 

 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;
}

 

 public function getValidationAttributes($attributes = null)
{
 if ($attributes === null) {
 return $this->getAttributeNames();
 }
 if (is_scalar($attributes)) {
 $attributes = [$attributes];
 }
 $newAttributes = [];
 $attributeNames = $this->getAttributeNames();
 foreach ($attributes as $attribute) {
 // do not strict compare, otherwise int attributes would fail due to to string conversion in getAttributeNames() using ltrim().
 if (in_array($attribute, $attributeNames, false)) {
 $newAttributes[] = $attribute;
 }
 }
 return $newAttributes;
}

 

 public function hasEventHandlers($name)
{
 $this->ensureBehaviors();
 if (!empty($this->_events[$name])) {
 return true;
 }
 foreach ($this->_eventWildcards as $wildcard => $handlers) {
 if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
 return true;
 }
 }
 return Event::hasHandlers($this, $name);
}

 

 public function hasMethod($name, $checkBehaviors = true)
{
 if (method_exists($this, $name)) {
 return true;
 } elseif ($checkBehaviors) {
 $this->ensureBehaviors();
 foreach ($this->_behaviors as $behavior) {
 if ($behavior->hasMethod($name)) {
 return true;
 }
 }
 }
 return false;
}

 

 public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
 return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

 

 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->tooFew === null) {
 $this->tooFew = Yii::t('yii', 'You should upload at least {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((string)$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((string)$this->mimeTypes), -1, PREG_SPLIT_NO_EMPTY);
 } else {
 $this->mimeTypes = array_map('strtolower', $this->mimeTypes);
 }
}

 

 public function isActive($scenario)
{
 return !in_array($scenario, $this->except, true) && (empty($this->on) || in_array($scenario, $this->on, true));
}

 

 public function isEmpty($value, $trim = false)
{
 $value = is_array($value) ? reset($value) : $value;
 return !($value instanceof UploadedFile) || $value->error == UPLOAD_ERR_NO_FILE;
}

 

 public function off($name, $handler = null)
{
 $this->ensureBehaviors();
 if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
 return false;
 }
 if ($handler === null) {
 unset($this->_events[$name], $this->_eventWildcards[$name]);
 return true;
 }
 $removed = false;
 // plain event names
 if (isset($this->_events[$name])) {
 foreach ($this->_events[$name] as $i => $event) {
 if ($event[0] === $handler) {
 unset($this->_events[$name][$i]);
 $removed = true;
 }
 }
 if ($removed) {
 $this->_events[$name] = array_values($this->_events[$name]);
 return true;
 }
 }
 // wildcard event names
 if (isset($this->_eventWildcards[$name])) {
 foreach ($this->_eventWildcards[$name] as $i => $event) {
 if ($event[0] === $handler) {
 unset($this->_eventWildcards[$name][$i]);
 $removed = true;
 }
 }
 if ($removed) {
 $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
 // remove empty wildcards to save future redundant regex checks:
 if (empty($this->_eventWildcards[$name])) {
 unset($this->_eventWildcards[$name]);
 }
 }
 }
 return $removed;
}

 

 public function on($name, $handler, $data = null, $append = true)
{
 $this->ensureBehaviors();
 if (strpos($name, '*') !== false) {
 if ($append || empty($this->_eventWildcards[$name])) {
 $this->_eventWildcards[$name][] = [$handler, $data];
 } else {
 array_unshift($this->_eventWildcards[$name], [$handler, $data]);
 }
 return;
 }
 if ($append || empty($this->_events[$name])) {
 $this->_events[$name][] = [$handler, $data];
 } else {
 array_unshift($this->_events[$name], [$handler, $data]);
 }
}

 

 public function trigger($name, ?Event $event = null)
{
 $this->ensureBehaviors();
 $eventHandlers = [];
 foreach ($this->_eventWildcards as $wildcard => $handlers) {
 if (StringHelper::matchWildcard($wildcard, $name)) {
 $eventHandlers[] = $handlers;
 }
 }
 if (!empty($this->_events[$name])) {
 $eventHandlers[] = $this->_events[$name];
 }
 if (!empty($eventHandlers)) {
 $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
 if ($event === null) {
 $event = new Event();
 }
 if ($event->sender === null) {
 $event->sender = $this;
 }
 $event->handled = false;
 $event->name = $name;
 foreach ($eventHandlers as $handler) {
 $event->data = $handler[1];
 call_user_func($handler[0], $event);
 // stop further handling if the event is handled
 if ($event->handled) {
 return;
 }
 }
 }
 // invoke class-level attached handlers
 Event::trigger($this, $name, $event);
}

 

 public function validate($value, &$error = null)
{
 $result = $this->validateValue($value);
 if (empty($result)) {
 return true;
 }
 list($message, $params) = $result;
 $params['attribute'] = Yii::t('yii', 'the input value');
 if (is_array($value)) {
 $params['value'] = 'array()';
 } elseif (is_object($value)) {
 $params['value'] = 'object';
 } else {
 $params['value'] = $value;
 }
 $error = $this->formatMessage($message, $params);
 return false;
}

 

 public function validateAttribute($model, $attribute)
{
 $files = $this->filterFiles(is_array($model->$attribute) ? $model->$attribute : [$model->$attribute]);
 $filesCount = count($files);
 if ($filesCount === 0) {
 $this->addError($model, $attribute, $this->uploadRequired);
 return;
 }
 if ($this->maxFiles > 0 && $filesCount > $this->maxFiles) {
 $this->addError($model, $attribute, $this->tooMany, ['limit' => $this->maxFiles]);
 }
 if ($this->minFiles > 0 && $this->minFiles > $filesCount) {
 $this->addError($model, $attribute, $this->tooFew, ['limit' => $this->minFiles]);
 }
 foreach ($files as $file) {
 $result = $this->validateValue($file);
 if (!empty($result)) {
 $this->addError($model, $attribute, $result[0], $result[1]);
 }
 }
}

 

 public function validateAttributes($model, $attributes = null)
{
 $attributes = $this->getValidationAttributes($attributes);
 foreach ($attributes as $attribute) {
 $skip = $this->skipOnError && $model->hasErrors($attribute)
 || $this->skipOnEmpty && $this->isEmpty($model->$attribute);
 if (!$skip) {
 if ($this->when === null || call_user_func($this->when, $model, $attribute)) {
 $this->validateAttribute($model, $attribute);
 }
 }
 }
}

 

 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 (!empty($this->extensions)) {
 foreach ((array) $this->extensions as $ext) {
 if ($extension === $ext || StringHelper::endsWith($file->name, ".$ext", false)) {
 return true;
 }
 }
 return false;
 }
 return true;
}

 

 protected function validateMimeType($file)
{
 $fileMimeType = $this->getMimeTypeByFile($file->tempName);
 if ($fileMimeType === null) {
 return false;
 }
 foreach ($this->mimeTypes as $mimeType) {
 if (strcasecmp($mimeType, $fileMimeType) === 0) {
 return true;
 }
 if (strpos($mimeType, '*') !== false && preg_match($this->buildMimeTypeRegexp($mimeType), $fileMimeType)) {
 return true;
 }
 }
 return false;
}

 

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