/**
* Fix bug where rules messages added with Validator::addRule were replaced after creating validator instance
*/
public function testRuleMessagesReplacedAfterConstructor()
{
$customMessage = 'custom message';
$ruleName = 'customRule';
$fieldName = 'fieldName';
Validator::addRule($ruleName, function () {
}, $customMessage);
$v = new Validator(array($fieldName => $fieldName));
$v->rule($ruleName, $fieldName);
$v->validate();
$messages = $v->errors();
$this->assertArrayHasKey($fieldName, $messages);
$this->assertEquals(ucfirst("{$fieldName} {$customMessage}"), $messages[$fieldName][0]);
}
/**
* @param Request $request
* @param Response $response
* @param $next
* @return Response
*/
public function __invoke(Request $request, Response $response, $next)
{
if ($this->validator->validate()) {
return $next($request, $response);
} else {
return $response->withJson($this->validator->errors(), 400);
}
}
function validateAddPlaceForm($place)
{
$v = new Validator($place);
$v->rule('required', ['name', 'address', 'tag_id']);
$v->rule('lengthMin', ['name'], 3);
return ['is_valid' => $v->validate(), 'has_errors' => $v->errors()];
}
public function prosesAdd()
{
if ($this->petugas == null) {
header("Location: " . base . "/Auth");
exit;
}
$valid = new Validator($_POST);
$valid->rule('required', ['title', 'author', 'publisher', 'category']);
if ($valid->validate()) {
$book = new Book();
$book->BookTitle = $_POST['title'];
$book->BookAuthor = $_POST['author'];
$book->PublisherID = $_POST['publisher'];
$book->CategoryID = $_POST['category'];
$book->BookPageCount = $_POST['pageCount'];
$book->BookPublished = $_POST['year'];
$book->BookDescription = $_POST['des'];
$book->BookPhoto = "acas";
$book->BookDateAdd = Carbon::now();
$book->BookPrice = $_POST['price'];
if ($book->save()) {
if ($_FILES['photo']['name'] != "") {
$uploaddir = '/var/www/limsmvc/img/';
$uploadfile = $uploaddir . $book->BookID;
move_uploaded_file($_FILES['photo']['tmp_name'], $uploadfile);
}
}
header("Location: " . base . "/Book");
} else {
// Errors
print_r($valid->errors());
}
}
function validateUserEditForm($user)
{
$v = new Validator($user);
$v->rule('required', ['full_name', 'email']);
$v->rule('lengthMin', ['full_name'], 3);
$v->rule('email', 'email');
return ['is_valid' => $v->validate(), 'has_errors' => $v->errors()];
}
public function testCustomLabels()
{
$messages = array('name' => array('Name is required'), 'email' => array('Email should be a valid email address'));
$v = new Validator(array('name' => '', 'email' => '$'));
$v->rule('required', 'name')->message('{field} is required');
$v->rule('email', 'email')->message('{field} should be a valid email address');
$v->labels(array('name' => 'Name', 'email' => 'Email'));
$v->validate();
$errors = $v->errors();
$this->assertEquals($messages, $errors);
}
public function testAddAddRuleWithCallbackFailMessage()
{
$v = new Validator(array("foo" => "baz"));
$v->rule(function ($field, $value) {
return $field === "foo" && $value === "bar";
}, "foo", "test error message");
$this->assertFalse($v->validate());
$errors = $v->errors();
$this->assertArrayHasKey("foo", $errors);
$this->assertCount(1, $errors["foo"]);
$this->assertEquals("Foo test error message", $errors["foo"][0]);
}
/**
* Validate required parameters for URL Generation.
*
* @param array $params
* @throws ValidationException
*/
protected function validate(array $params)
{
$validator = new Validator($params);
$validator->rule('required', $this->rules);
if (!$validator->validate()) {
$errors = '';
foreach ($validator->errors() as $key => $value) {
$errors .= $key . ' is required. ';
}
throw new ValidationException($errors);
}
}
/**
* Method that validates fields of the entity based on its restrictions
*/
protected function validateFields()
{
$validator = new Validator($this->data, [], 'en');
//@todo: if use external i18n library?
if ($this->action == 'new') {
$validator->rules(array_merge($this->rulesNew, $this->rulesGlobal));
} else {
$validator->rules(array_merge($this->rulesModify, $this->rulesGlobal));
}
if (!$validator->validate()) {
$this->errors = array_merge($this->errors, $validator->errors());
}
}
/**
* validasi
* @param array $data POST data
* @return boolean
*/
public function validate($data)
{
$v = new Validator($data, [], 'id');
foreach ($this->rules as $rule => $columns) {
$v->rule($rule, $columns);
}
$v->labels($this->labels);
if ($v->validate()) {
return true;
} else {
$this->errors = $v->errors();
return false;
}
}
private function validateConfig($config)
{
if (!is_array($config)) {
// Throw exception
throw new InvalidDataTypeFoundException("Expected array but found " . gettype($config) . " instead", 1004);
}
$validator = new Valitron($config);
$validator->rule('required', ['AKAMAI_KEY', 'AKAMAI_KEYNAME', 'AKAMAI_HOST']);
$validator->rule('length', 'AKAMAI_KEY', 50);
if (!$validator->validate()) {
// Concatinate all message and Throw exception
$message = implode(', ', ArrayHelper::flatten($validator->errors()));
throw new ValidationException($message, 1007);
}
return $config;
}
public function validate($datas = [])
{
foreach (get_class_methods($this) as $funcRule) {
if (stripos($funcRule, 'rule') === 0 && $funcRule != 'rules') {
$args = $this->{$funcRule}();
array_unshift($args, lcfirst(str_replace('rule', '', $funcRule)));
call_user_func_array('\\Valitron\\Validator::addRule', $args);
}
}
if ($datas == null) {
$datas = get_object_vars($this);
}
$validator = new Validator($datas);
foreach ($this->rules() as $args) {
call_user_func_array([$validator, 'rule'], $args);
}
if ($validator->validate()) {
return null;
}
return $validator->errors();
}
public static function attempt(array $credentials, $remember_me = false)
{
$input_email = filter_var($credentials['email'], FILTER_SANITIZE_STRING);
$input_password = filter_var($credentials['pass'], FILTER_SANITIZE_STRING);
//run validation
$v = new Validator($credentials);
$v->rule('email', 'email')->message('Please provide an valid Email address');
$v->rule('required', 'email')->message('Email is required');
$v->rule('required', 'pass')->message('Please provide an password');
if (!$v->validate()) {
return array('errors' => $v->errors());
}
//data valid so proceed to next
try {
$m = new \QueryBuilder();
$user = $m->select('users', array('email = :email', array('email' => array($input_email, \PDO::PARAM_STR))));
if (!$user) {
throw new \Exception('No user found with this credential', 5002);
}
$stored_password_hash = $user['password'];
if (password_verify($input_password, $stored_password_hash)) {
$_SESSION['auth.user.logged_in'] = true;
$_SESSION['auth.user.id'] = $user['id'];
if ($remember_me === true) {
$auth_config = load_config('auth');
//set token and it's validity period
$remember_token = uniqid('rem_');
$remember_validity = time() + $auth_config['login_cookie_expire'];
$m->update('users', array('remember_token' => array($remember_token, \PDO::PARAM_STR), 'token_validity' => array(date('Y-m-d H:i:s', $remember_validity), \PDO::PARAM_STR)), array('id = :id', array('id' => array(intval($user['id']), \PDO::PARAM_INT))));
setcookie($auth_config['login_cookie_name'], $remember_token, $remember_validity);
}
return true;
} else {
throw new \Exception('Invalid credential. Please provide valid username and password.', 5003);
}
} catch (\Exception $ex) {
throw $ex;
}
}
/**
* Validate the IodefElement's attributes and value.
* @return boolval
*/
protected function validate()
{
// If attributes are set, validate them.
if (!empty($this->attributes)) {
// It's possible that there are no rules for the attributes available.
// If so, skip attribute validation.
if (sizeof($this->getAttributeRules()) > 0) {
$validate_attributes = new Validator($this->attributes);
$validate_attributes->rules($this->getAttributeRules());
// Validation failed to succeeed, show errors
if (!$validate_attributes->validate()) {
echo 'Some attributes failed to pass the validator:';
foreach ($validate_attributes->errors() as $failed_attr) {
echo ' ' . $failed_attr[0];
}
return false;
}
}
}
// If a value is set, validate it.
if (array_key_exists('value', $this)) {
// It's possible that there is no value rule set.
// If so, skip value validation.
if (sizeof($this->getValueRule()) > 0) {
$validate_value = new Validator(['value' => $this->value]);
$validate_value->rules($this->getValueRule());
// Validation failed to succeeed, show errors
if (!$validate_value->validate()) {
echo 'The value failed to pass the validator:';
foreach ($validate_value->errors() as $message) {
echo ' ' . $message;
}
return false;
}
}
}
return true;
}
/**
* Validate an object using the data and rules passed in
*
* Will update the last result with validation errors
*
* @param array $aData The data to validate
* @param array $aRules The results to apply
*
* @return boolean true if valid false otherwise
*/
public function validate($aData, $aRules)
{
$oValidator = new Validator($aData);
$oValidator->rules($aRules);
$bValid = $oValidator->validate();
if (false === $bValid) {
$this->aLastResult['result'] = false;
$this->aLastResult['msg'] = $oValidator->errors();
}
return $bValid;
}
/**
* Run validation against $this->rules
*
* @param array $data
* @return Message|bool
*/
public static function validate(array $data)
{
$validator = new Validator($data);
$validator->rules(static::$rules);
if ($validator->validate()) {
return true;
} else {
return new Message($validator->errors());
}
}
$foundProfile = Doctrine::findMembre($numeroMembre);
// Don't generate method calls to avoid potential security hole.
$foundProfile->setStatut($formValues['statut']);
$foundProfile->setEnfants($formValues['enfants']);
$foundProfile->setDevise($formValues['devise']);
$foundProfile->setCoordonnee('email', $formValues['email'], $formValues['emailPrive']);
$foundProfile->setCoordonnee('phone', $formValues['telephone'], $formValues['telephonePrive']);
$adresseValue = ['address' => trim("{$formValues['adresse1']}\n{$formValues['adresse2']}\n{$formValues['adresse3']}"), 'code' => $formValues['codePostal'], 'city' => $formValues['ville'], 'country' => $formValues['pays']];
$foundProfile->setCoordonnee('address', json_encode($adresseValue), $formValues['adressePrivee']);
$foundProfile->setLangues(getArrayValue($formValues, 'langues'));
$foundProfile->setCompetences(getArrayValue($formValues, 'competences'));
$foundProfile->setPassions(getArrayValue($formValues, 'passions'));
Doctrine::persist($foundProfile);
Doctrine::flush();
$ldapResult = LdapSync::updateProfile($numeroMembre, $foundProfile->jsonSerialize());
if ($ldapResult) {
// Then it's an error.
$logger->error("Ldap error updating status for #{$numeroMembre}: {$ldapResult}");
}
echo json_encode($foundProfile);
} else {
$logger->info('Found validation errors: ' . print_r($v->errors(), true));
$errors = [];
foreach ($v->errors() as $fieldName => $fieldErrors) {
foreach ($fieldErrors as $message) {
$errors[] = $message;
}
}
$logger->info('Found validation errors: ' . print_r($errors, true));
echo json_encode(['errors' => $errors]);
}
public function testCustomLabelArrayWithoutMessage()
{
$v = new Valitron\Validator(array('password' => 'foo', 'passwordConfirm' => 'bar'));
$v->rule('equals', 'password', 'passwordConfirm');
$v->labels(array('password' => 'Password', 'passwordConfirm' => 'Password Confirm'));
$v->validate();
$this->assertEquals(array('password' => array("Password must be the same as 'Password Confirm'")), $v->errors());
}
public function testInstanceOfErrorMessageShowsInstanceName()
{
$v = new Validator(array('attributeName' => new Validator(array())));
$v->rule('instanceOf', 'attributeName', new stdClass());
$v->validate();
$expected_error = array("attributeName" => array("AttributeName must be an instance of 'stdClass'"));
$this->assertEquals($expected_error, $v->errors());
}
/**
* Validates if the assign properties are valid for a database insert
*
* @return boolean true if
*/
public function validate()
{
$aFields = array('voucherCode' => $this->getVoucherCode(), 'voucherTypeId' => $this->getVoucherTypeId(), 'voucherInstanceId' => $this->getVoucherInstanceId());
$v = new Validator($aFields);
$v->rule('lengthBetween', array('voucherCode'), 1, 255);
$v->rule('required', array('voucherCode', 'voucherTypeId'));
$v->rule('min', array('voucherInstanceId'), 1);
if ($v->validate()) {
return true;
} else {
return $v->errors();
}
}
/**
* Validates if the assign properties are valid for a
* database insert
*
* @return boolean true if
*/
public function validate()
{
$aFields = array('voucherID' => $this->getVoucherGroupId(), 'name' => $this->getVoucherGroupName(), 'sortOrder' => $this->getSortOrder(), 'isDisabled' => $this->getDisabledStatus(), 'slugName' => $this->getSlugName());
$v = new Validator($aFields);
$v->rule('slug', 'slugName');
$v->rule('lengthBetween', array('slugName', 'name'), 1, 100);
$v->rule('required', array('slugName', 'name', 'isDisabled'));
$v->rule('min', array('voucherID'), 1);
if ($v->validate()) {
return true;
} else {
return $v->errors();
}
}
private function validateBillingParams($params)
{
$validator = new Validator($params);
$validator->rule('required', ['transactionId', 'firstName', 'lastName', 'address1', 'address2', 'city', 'state', 'country', 'telNo', 'email']);
if (!$validator->validate()) {
$errors = '';
foreach ($validator->errors() as $key => $value) {
$errors .= $key . ' is required. ';
}
throw new ValidationException($errors);
}
}
public function testWithData()
{
$v = new Validator(array());
$v->rule('required', 'name');
//validation failed, so must have errors
$this->assertFalse($v->validate());
$this->assertNotEmpty($v->errors());
//create copy with different data
$v2 = $v->withData(array('name' => 'Chester Tester'));
$this->assertTrue($v2->validate());
$this->assertEmpty($v2->errors());
}
/**
* @dataProvider dataProviderFor_testError
*/
public function testError($expected, $input, $test, $message)
{
$v = new Validator(array('test' => $input));
$v->error('test', $message, $test);
$this->assertEquals(array('test' => array($expected)), $v->errors());
}
/**
* Validates if the assign properties are valid for a database insert
*
* @return boolean true if
*/
public function validate()
{
$aFields = array('voucherTypeId' => $this->getVoucherTypeId(), 'voucherGenRuleId' => $this->getVoucherGenRuleID(), 'voucherGroupId' => $this->getVoucherGroupId(), 'voucherEnabledFrom' => $this->getEnabledFrom(), 'voucherEnabledTo' => $this->getEnabledTo(), 'voucherDescription' => $this->getDescription(), 'voucherName' => $this->getName(), 'voucherNameSlug' => $this->getSlug());
$v = new Validator($aFields);
$v->rule('lengthBetween', array('voucherNameSlug', 'voucherName'), 1, 100);
$v->rule('lengthBetween', array('voucherDescription'), 1, 500);
$v->rule('required', array('voucherNameSlug', 'voucherNameSlug', 'voucherGenRuleId', 'voucherGroupId', 'voucherEnabledFrom', 'voucherEnabledTo'));
$v->rule('min', array('voucherTypeId', 'voucherGroupId', 'voucherGenRuleId'), 1);
$v->rule('slug', array('voucherNameSlug'));
$v->rule('dateBefore', array('voucherEnabledFrom'), $this->getEnabledTo());
if ($v->validate()) {
return true;
} else {
return $v->errors();
}
}
private function validate($data)
{
$v = new Validator($data);
$v->rule('required', ['gender', 'age', 'height', 'weight']);
$v->rule('numeric', ['age', 'height', 'weight']);
$v->rule('in', 'gender', [self::MALE, self::FEMALE])->message('Gender must be specified');
$v->rule('max', 'height', 2.5);
$v->rule('notIn', 'height', [0])->message('{field} - zero is not allowed here');
$v->rule('min', 'weight', 30);
$v->rule('min', 'age', 21)->message('This formula applies only to adults (more than 21 years old )');
$this->valid = $v->validate();
$this->errors = $v->errors();
d($this->errors);
}
/**
* @return array
*/
public function errors()
{
return $this->validator->errors();
}
public function testCollectFirstErrorsOnly()
{
$data = ["key" => ""];
// collect the first errors only
$v = new Validator($data);
$v->stopOnError(true);
$v->rule("required", ["key"])->message("is_required");
$v->rule("equals", "key", "expected_value")->message("is_not_equals");
$res = $v->validate();
$errors = $v->errors();
$this->assertEquals(1, count($errors["key"]), "it must contains only the first error");
$this->assertEquals("is_required", $errors["key"][0], "it must contains 'is_not_equals' message");
// collect all errors
$v = new Validator($data);
$v->stopOnError(false);
// it is FALSE by default
$v->rule("required", ["key"])->message("is_required");
$v->rule("equals", "key", "expected_value")->message("is_not_equals");
$res = $v->validate();
$errors = $v->errors();
$this->assertEquals(2, count($errors["key"]), "it must contains only the first error");
$this->assertEquals("is_required", $errors["key"][0], "it must contains 'is_required' message");
$this->assertEquals("is_not_equals", $errors["key"][1], "it must contains 'is_not_equals' message");
$this->assertFalse($res);
}
static function callValitron($arr, $rules, $throw = TRUE)
{
$v = new Validator($arr);
$v->rules($rules);
if (!$v->validate()) {
if ($throw) {
throw (new \RoyalMail\Exception\RequestException())->withErrors($v->errors());
}
return $v->errors();
} else {
return TRUE;
}
}
/**
* Validates if the assign properties are valid for a
* database insert
*
* @return boolean true if
*/
public function validate()
{
$aFields = array('voucherGenRuleID' => $this->getVoucherGenRuleId(), 'slugName' => $this->getSlugRuleName(), 'voucherRuleName' => $this->getVoucherRuleName(), 'voucherPaddingChar' => $this->getVoucherPaddingCharacter(), 'voucherSuffix' => $this->getVoucherSuffix(), 'voucherPrefix' => $this->getVoucherPrefix(), 'voucherLength' => $this->getVoucherLength(), 'sequenceStrategy' => $this->getSequenceStrategyName());
// ensure total length < 255 column size for the voucher code
// generated with the current db schema and size of padding,suffix
$iTotalLength = (int) $this->getVoucherLength();
$iTotalLength += mb_strlen((string) $this->getVoucherSuffix());
$iTotalLength += mb_strlen((string) $this->getVoucherPrefix());
$aFields['totalLength'] = $iTotalLength;
$v = new Validator($aFields);
$v->rule('slug', 'slugName');
$v->rule('length', array('voucherPaddingChar'), 1);
$v->rule('lengthBetween', array('slugName', 'name'), 1, 25);
$v->rule('lengthBetween', array('voucherSuffix', 'voucherPrefix'), 0, 50);
$v->rule('lengthBetween', array('totalLength'), 1, 255);
$v->rule('required', array('slugName', 'voucherRuleName', 'voucherLength'));
$v->rule('min', array('voucherGenRuleID', 'voucherLength'), 1);
$v->rule('max', array('voucherLength'), 100);
// this number of characters in unique number not max possible number
$v->rule('in', array('sequenceStrategy'), array('UUID', 'SEQUENCE'));
if ($v->validate()) {
return true;
} else {
return $v->errors();
}
}
