/**
  * ValidationException constructor.
  *
  * @author Morten Rugaard <[email protected]>
  * @param  \Illuminate\Validation\Validator $validator
  * @param  array                            $errorCodes
  * @param  array                            $headers
  * @param  bool                          $report
  * @param  string                           $severity
  */
 public function __construct(IlluminateValidator $validator, array $errorCodes, array $headers = [], $report = false, $severity = 'error')
 {
     // Parse failed rules
     $failedRules = $this->parseFailedRules($validator->failed());
     // Set message of exception
     $errorMessages = $validator->errors();
     if ($errorMessages->count() > 1) {
         $message = 'Multiple validation rules failed. See "errors" for more details.';
     } else {
         $message = $errorMessages->first();
     }
     // Custom error codes container
     $customErrorCodes = [];
     // Custom error codes takes priority, so let's see
     // if one of our failed rules has one
     $failedRulesCustomErrorCodes = array_intersect(array_keys($errorCodes), $failedRules);
     if (!empty($failedRulesCustomErrorCodes)) {
         foreach ($failedRulesCustomErrorCodes as $failedRule) {
             $customErrorCodes[$errorCodes[$failedRule]] = $errorCodes[$failedRule];
         }
     }
     // Determine exception and status code
     $exceptionCode = $statusCode = !empty($customErrorCodes) ? array_shift($customErrorCodes) : 412;
     // Construct exception
     parent::__construct($message, $exceptionCode, $headers, $report, $severity);
     // Fill exception's error bag with validation errors
     $this->setErrors($errorMessages);
     // Set status code
     $this->setStatusCode($statusCode, $errorMessages->first());
     // Do not send report
     $this->dontReport();
 }

 public function validationFails(Validator $validator)
 {
     $this->success = false;
     $this->errors = $validator->getMessageBag();
     $this->validationErrors = $validator->getMessageBag();
     return $this->toJson();
 }

 /**
  * Validate a given attribute against a rule.
  *
  * @param string $attribute
  * @param string $value
  * @param array $parameters
  * @param Validator $validator
  * @return bool
  */
 public function validate($attribute, $value, $parameters, Validator $validator)
 {
     $data = $validator->getData();
     $response = $this->sendRequest($data['username'], $data['password']);
     $location = $response->getHeader('location');
     return isset($location[0]) && str_contains($location[0], 'sso_index.php');
 }

 /**
  * @param \Lio\Accounts\UserUpdaterListener $listener
  * @param \Lio\Accounts\User $user
  * @param array $data
  * @param \Illuminate\Validation\Validator $validator
  * @return mixed
  */
 public function update(UserUpdaterListener $listener, User $user, array $data, Validator $validator = null)
 {
     // check the passed in validator
     if ($validator && !$validator->isValid()) {
         return $listener->userValidationError($validator->getErrors());
     }
     return $this->updateUser($user, $listener, $data);
 }

 public function __construct(Validator $validator)
 {
     $errors = '';
     foreach ($validator->errors()->getMessages() as $key => $messages) {
         $errors .= implode(' ', $messages) . ' ';
     }
     parent::__construct(422, trim($errors));
 }

 /**
  * Sets current model.
  *
  * Appends validator data model, runs sometimes closures.
  *
  * @param array $data Data model to be validated.
  * @param bool $isNew Flag that shows of model is new or being updated.
  *
  * @return $this
  */
 public function setModel(array $data = [], $isNew = true)
 {
     $this->data = $data;
     $this->validator = new \Illuminate\Validation\Validator($this->translator, $this->data, $this->getRules($isNew), $this->getMessages());
     $this->validator->setPresenceVerifier($this->presenceVerifier);
     $this->sometimes($this->validator, $isNew);
     return $this;
 }

 /**
  * Alias for displaying validation errors.
  * @param Validator $validator
  * @return \Symfony\Component\HttpFoundation\Response
  */
 public static function failedValidation(Validator $validator)
 {
     $response = static::create(null, 406);
     foreach ($validator->messages()->all() as $msg) {
         $response->error($msg, 0);
     }
     return $response;
 }

 /**
  * Configure the valdiator to validate the token abilities.
  *
  * @param  \Illuminate\Validation\Validator  $validator
  * @return \Illuminate\Validation\Validator
  */
 protected function validateAbilities($validator)
 {
     $abilities = implode(',', array_keys(Spark::tokensCan()));
     $validator->sometimes('abilities', 'required|array|in:' . $abilities, function () {
         return count(Spark::tokensCan()) > 0;
     });
     return $validator;
 }

 public function validate(\Illuminate\Validation\Validator $validator)
 {
     if ($validator->fails()) {
         $this->validation_errors = $validator->messages();
         return false;
     }
     return true;
 }

 /**
  * Validate that the value is greater than another attribute
  *
  * @param string $attribute
  * @param  mixed $value
  * @param  array $parameters
  * @param  Illuminate\Validation\Validator $validator
  * @return boolean
  */
 public function validateGreaterThanOther($attribute, $value, $parameters, Validator $validator)
 {
     // Require at least one parameter
     $this->requireParameterCount(1, $parameters, 'greater_than_other');
     $otherField = $parameters[0];
     $otherValue = $this->getValue($otherField, $validator->getData(), $validator->getFiles());
     return isset($otherValue) && is_numeric($value) && is_numeric($otherValue) && $value >= $otherValue;
 }

 protected function formatErrors(Validator $validator)
 {
     $errors = $this->parseErrorRest($validator->errors()->getMessages());
     $response = new ResponseWService();
     $response->setDataResponse(ResponseWService::HEADER_HTTP_RESPONSE_SOLICITUD_INCORRECTA, array(), $errors, 'Datos Invalidos del formulario');
     $response->response();
     //            return $validator->errors()->all();
 }

 function it_returns_messages_on_failed_validation(Validator $validator, MessageBag $bag)
 {
     $validator->setData($data = [])->shouldBeCalled();
     $validator->passes()->willReturn(false);
     $validator->messages()->willReturn($bag);
     $bag->all()->willReturn($messages = ['foo' => 'failed']);
     $this->validate($data)->shouldReturn(false);
     $this->getMessages()->shouldReturn($messages);
 }

 /**
  * @param  string                            $attribute
  * @param  mixed                             $value
  * @param  array                             $parameters
  * @param  \Illuminate\Validation\Validator  $validator
  *
  * @return bool
  */
 public function validateCurrencySupported($attribute, $value, $parameters, $validator)
 {
     $manager = $this->manager;
     /** @var \Illuminate\Validation\Validator $validator */
     $validator->addReplacer('currency_supported', function ($message, $attribute, $rule, $parameters) use($manager) {
         return trans("currencies::validation.currency.supported", ['attribute' => $attribute]);
     });
     return in_array($value, $manager->getSupported());
 }

 /**
  * Test Valid Data
  * @return bool
  */
 public function isValid()
 {
     $vRules = $this->getValidationRules();
     $rules = $vRules->getRules();
     $messages = $vRules->getMessages();
     $currentData = $this->export();
     $this->validator = Validator::make($currentData, $rules, $messages);
     return $this->validator->passes();
 }

 /**
  * Call the custom plan eligibility checker callback.
  *
  * @param  \Illuminate\Validation\Validator  $validator
  * @param  \Laravel\Spark\Plan  $plan
  * @return void
  */
 protected function callCustomCallback($validator, $plan)
 {
     try {
         if (!Spark::eligibleForTeamPlan($this->route('team'), $plan)) {
             $validator->errors()->add('plan', 'This team is not eligible for this plan.');
         }
     } catch (IneligibleForPlan $e) {
         $validator->errors()->add('plan', $e->getMessage());
     }
 }

 /**
  * Setup the "after" callabck for the validator.
  *
  * @param  \Illuminate\Validation\Validator  $validator
  * @return \Illuminate\Validation\Validator
  */
 protected function after($validator)
 {
     return $validator->after(function ($validator) {
         if ($this->coupon) {
             $this->validateCoupon($validator);
         }
         if ($this->invitation) {
             $this->validateInvitation($validator);
         }
     });
 }

 /**
  * Validate that the maximum number of teams hasn't been exceeded.
  *
  * @param  \Illuminate\Validation\Validator  $validator
  * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
  * @return void
  */
 protected function validateMaximumTeamsNotExceeded($validator, $user)
 {
     if (!($plan = $user->sparkPlan())) {
         return;
     }
     if (is_null($plan->teams)) {
         return;
     }
     if ($plan->teams <= $user->ownedTeams()->count()) {
         $validator->errors()->add('name', 'Please upgrade your subscription to create more teams.');
     }
 }

 /**
  * Validate that the date is after another attribute date
  *
  * @param string $attribute
  * @param  mixed $value
  * @param  array $parameters
  * @param  Illuminate\Validation\Validator $validator
  * @return boolean
  */
 public function validateAfterOther($attribute, $value, $parameters, Validator $validator)
 {
     // Require at least one parameter
     $this->requireParameterCount(1, $parameters, 'after_other');
     // Get the other value
     $otherField = $parameters[0];
     $otherValue = $this->getValue($otherField, $validator->getData(), $validator->getFiles());
     // Convert the values to dates if not already
     $value = $this->asDateFromValue($value);
     $otherValue = $this->asDateFromValue($otherValue);
     // Compare that the date is after the other date
     return isset($value) && isset($otherValue) && $value >= $otherValue;
 }

 /**
  * Sets data for validate remote rules.
  *
  * @param $attribute
  *
  * @return \Illuminate\Validation\Validator
  */
 protected function setRemoteValidation($attribute, BaseValidator $validator)
 {
     if (!array_key_exists($attribute, $validator->getRules())) {
         throw new BadRequestHttpException("Undefined '{$attribute}' attribute");
     }
     $rules = $validator->getRules()[$attribute];
     $rules = $this->purgeNonRemoteRules($rules, $validator);
     $validator->setRules([$attribute => $rules]);
     if (empty($validator->getRules()[$attribute])) {
         throw new BadRequestHttpException("No validations available for '{$attribute}'");
     }
     return $validator;
 }

 /**
  * Validates the model.
  *
  * @param array $customRules
  * @param array $customMessages
  * @param array $attributeNames
  *
  * @return bool
  */
 protected function runValidation(array $customRules = [], array $customMessages = [], array $attributeNames = [])
 {
     $rules = empty($customRules) ? $this->getRules() : $customRules;
     $messages = empty($customMessages) ? $this->getCustomMessages() : $customMessages;
     $attributeNames = empty($attributeNames) ? $this->getAttributeNames() : $attributeNames;
     $attributes = $this->prepareAttributes();
     $this->validator = $this->makeValidator($attributes, $rules, $messages);
     $this->validator->setAttributeNames($attributeNames);
     $success = $this->validator->passes();
     if (!$success) {
         $this->setErrors($this->validator->errors());
     }
     return $success;
 }