Validation error message for the storing rule.

@param MessageBag $errors
171316
public function createBannedEmailFailedValidation(MessageBag $errors)
    {
        $message = implode("\n\r", $errors->all());
        $this->error($message);
    }
715327
public function errors($errors = null) {
        if(is_null($errors)) {
            return $this->errors;
        }
        $this->errors = $errors;
    }
770775
protected function addError($message, $code, array $arguments = [])
    {
        $this->result->addError(new ValidationError($message, $code, $arguments));
    }
906531
private function setMessageset(array $messages = [])
    {
        // Passed messages rule, but we will use model messages if nothing has been passed
        $this->messageset = $this->selectMessages($messages);

        // If we don't have any rules, don't do anything because an error will never occur
        if ( ! count($this->rules)) return;

        // Determine file for validation messages
        $file = $this->languageFolder . '/' . str_replace('\\', '/', get_called_class()) . '.';

        $this->messages = [];

        // Process each rule
        foreach($this->rules as $field => $set)
        {
            foreach ($set as $rule)
            {
                // Remove parameters if we have them
                list($type,) = $this->getRuleTypeAndParameters($rule);

                // Generate a key using language file dot notation e.g. 'username.required'
                $key = implode('.', [$field, $type]);

                // Try to find a suitable error message
                $message = $this->getMessage($file, $key);
                if ($message) $this->messages[$key] = $message;
            }
        }
    }
931876
protected function setValidation($values)
    {
        foreach ($values as $validation) {
            $value = isset($validation->value) ? $validation->value : true;

            $this->validation[$validation->rule] = $value;
        }
    }
349464
public void addErrorMsgs(final Set<String> msgs) {
    if (msgs != null) {
      this._errorMsgs.addAll(msgs);
      if (!msgs.isEmpty()) {
        this._status = ValidationStatus.ERROR;
      }
    }
  }
961839
public function createRuleFailedValidation(MessageBag $errors)
    {
        app('antares.messages')->add('error', $errors);
        $url = handles('ban_management.rules.create');

        return $this->redirectWithErrors($url, $errors);
    }
92718
final public static function setError (string $errorMessage=NULL) : bool
	{
		static::$error = "";
		if (!static::hasValue($errorMessage)) return FALSE;
		static::$error = "Check the following field(s) ".stripComma($errorMessage)." and try again.";
		return TRUE;
	}
631461
public function validate(EntityContract $entity, Bag $parameters)
    {
        $errors = new Collection();

        $this->callMethods('validate', [$entity, $parameters], function ($return) use (&$errors) {
            $errors = $errors->merge($return);
        });

        return $errors;
    }
768022
protected function validateArgs(): void
    {
        if (! $this->rules) {
            return;
        }

        $validator = validator(
            $this->args,
            $this->rules,
            $this->messages,
            [
                'root' => $this->root,
                'context' => $this->context,
                // This makes it so that we get an instance of our own Validator class
                'resolveInfo' => $this->resolveInfo,
            ]
        );

        if ($validator->fails()) {
            foreach ($validator->errors()->getMessages() as $key => $errorMessages) {
                foreach ($errorMessages as $errorMessage) {
                    $this->validationErrorBuffer->push($errorMessage, $key);
                }
            }
        }

        $path = implode(
            '.',
            $this->resolveInfo()->path
        );
        $this->validationErrorBuffer->flush(
            "Validation failed for the field [$path]."
        );

        // reset rules and messages
        $this->rules = [];
        $this->messages = [];
    }
235110
public static function set_error_message($rule, $message)
    {
        $gump = self::get_instance();
        self::$validation_methods_errors[$rule] = $message;
    }
116698
public function errors($errors)
    {
        $this->success = false;
        $this->data['errors'] = $errors instanceof MessageBag
            ? $errors->toArray()
            : $errors;

        return $this;
    }
990603
public function storeRuleFailed(array $errors)
    {
        $url     = handles('antares::ban_management/rules/datatable');
        $message = trans('antares/ban_management::response.rules.create.db-failed', $errors);

        return $this->redirectWithMessage($url, $message, 'error');
    }
1003190
public static function error(...$messages): void
    {
        static::init();

        if (!static::isTemporaryDisabled('error')) {
            foreach (static::$adapters as $adapter) {
                /* @var $adapter \Koldy\Log\Adapter\AbstractLogAdapter */
                if ($adapter->isLevelEnabled(self::ERROR)) {
                    $adapter->error((new Message(self::ERROR))->setMessages($messages));
                }
            }
        }
    }
1048344
protected function log_error($errors) {
        if (empty($errors)) {
            return;
        }

        foreach ($errors as $code => $langstring) {
            if (!isset($this->errors[$this->linenb])) {
                $this->errors[$this->linenb] = array();
            }
            $this->errors[$this->linenb][$code] = $langstring;
        }
    }
1117964
protected function validateOnPost(ErrorCollection $errors)
    {
        $this->validateAttributes([
            Schema::ATTR_TITLE => 'required|max:' . Model::LENGTH_TITLE,
        ], $errors);
    }
1314567
public function validate(BaseModel $model, $rules = null, $messages = [])
    {
        return $this->validateAndPrefixErrors(null, $model, $rules, $messages);
    }