protected function setValidationRules($validator)
{
$required = new Validator();
$required->notEmpty();
$validator->attribute('name', $required);
$validator->attribute('content', $required);
}
public function validate($prop, $label)
{
$value = $this->getValue($prop);
if (!v::string()->cnpj()->validate($value)) {
$this->addException("O preenchimento do campo {$label} está inválido");
}
}
/**
* Returns the number of characters in memory after parsing given string.
* @param string $string
* @return int
* @throws ParseException
*/
public static function charsInMemory($string)
{
if (!Validator::stringType()->regex('/".*"/')->validate($string)) {
throw new ParseException('String must be surrounded by double quotes (")');
}
return preg_match_all("/(\\\\\\\\|\\\\\"|\\\\x[[:xdigit:]]{2}|.)/", substr($string, 1, strlen($string) - 2));
}
/**
* @param $cardNumber
* @return array
* @throws NumberValidateException
*/
public static function validate($cardNumber)
{
if (!v::numeric()->noWhitespace()->validate($cardNumber)) {
throw new NumberValidateException();
}
return ['valid' => true, 'type' => 'visa'];
}
public function setAlternativeEmail($value)
{
if (!v::email()->validate($value)) {
throw new FieldRequiredException("E-mail alternativo inválido");
}
$this->_email .= "," . $value;
}
public function __construct(Client $client, $key)
{
$this->client = $client;
$this->key = $key;
$baseUrl = $this->client->getConfig('base_uri');
Validator::notEmpty()->url()->endsWith('/')->setName("URL for NewRelic's Insights API must be valid and have a trailing slash")->assert($baseUrl);
}
public function isValid($validation_data)
{
$errors = [];
foreach ($validation_data as $name => $value) {
if (isset($_REQUEST[$name])) {
$rules = explode("|", $value);
foreach ($rules as $rule) {
$exploded = explode(":", $rule);
switch ($exploded[0]) {
case 'min':
$min = $exploded[1];
if (Valid::stringType()->length($min)->Validate($_REQUEST[$name]) == false) {
$errors[] = $name . " must be at least " . $min . " characters long";
}
break;
case 'email':
if (Valid::email()->Validate($_REQUEST[$name]) == false) {
$errors[] = $name . " must be a valid email ";
}
break;
case 'equalTo':
if (Valid::equals($_REQUEST[$name])->Validate($_REQUEST[$exploded[1]]) == false) {
$errors[] = "Values do not match";
}
break;
default:
//do nothing
}
}
} else {
$errors = "No value found";
}
}
return $errors;
}
/**
* Validator constructor.
* @param array $rules Array where each key corresponds to one attribute of the model and the value is a list of
* validation rules supported by Respect\Validation separated by the pipe ("|") character.
*/
public function __construct(array $rules)
{
foreach ($rules as $field => $rule) {
$this->addAttribute($field, $rule);
}
parent::__construct();
}
private function _validate($param, $type)
{
$libConfig = $GLOBALS['app']->getConfiguration()->getRawConfiguration('library');
$minNameVal = $libConfig["product"]["minNameLength"];
$maxNameVal = $libConfig["product"]["maxNameLength"];
$minCodeVal = $libConfig["product"]["minCodeLength"];
$maxCodeVal = $libConfig["product"]["maxCodeLength"];
$validateName = v::alnum('-_')->length($minNameVal, $maxNameVal);
$validateCode = v::alnum('-_')->noWhitespace()->length($minCodeVal, $maxCodeVal);
$validateToken = v::alnum('-_');
if (strcmp($type, "name") === 0) {
$isValid = $validateName->validate($param);
if (!$isValid) {
throw new \InvalidArgumentException(\Akzo\Product\ErrorMessages::INVALID_PRODUCT_NAME, \Native5\Core\Http\StatusCodes::NOT_ACCEPTABLE);
}
} else {
if (strcmp($type, "code") === 0) {
$isValid = $validateCode->validate($param);
if (!$isValid) {
throw new \InvalidArgumentException(\Akzo\Product\ErrorMessages::INVALID_PRODUCT_CODE, \Native5\Core\Http\StatusCodes::NOT_ACCEPTABLE);
}
} else {
if (strcmp($type, "token") === 0) {
$isValid = $validateToken->validate($param);
if (!$isValid) {
throw new \InvalidArgumentException(\Akzo\Product\ErrorMessages::INVALID_TOKEN, \Native5\Core\Http\StatusCodes::NOT_ACCEPTABLE);
}
} else {
throw new \InvalidArgumentException('Invalid Validation Type', \Native5\Core\Http\StatusCodes::NOT_ACCEPTABLE);
}
}
}
}
protected function validate()
{
$data = filter_input(INPUT_POST, $this->model);
$error = false;
foreach ($this->validation_rules as $field => $config) {
$validator = new v();
$validator->addRules($config['rules']);
if ($config['optional']) {
$this->validate[$field] = v::optional($validator);
} else {
$this->validate[$field] = $validator;
}
$error = $this->validate[$field]->validate($data[$field]);
}
return $error;
}
/**
* Execute la suite de tests.
*
* @param mixed $void Ne sert à rien. Ne pas utiliser.
* @return null|boolean Si vaut null, cela signifie que la valeur à tester n'existe pas.<br/>
* Vaut TRUE ou FALSE selon la réussite de la suite des assertions.
*/
public function validate($void = '')
{
if ($this->_bReturnNull) {
return null;
}
return parent::validate($this->_mValueToTest);
}
public function isValid($validation_data)
{
$errors = "";
foreach ($validation_data as $name => $value) {
$rules = explode("|", $value);
foreach ($rules as $rule) {
$exploded = explode(":", $rule);
switch ($exploded[0]) {
case 'min':
$min = $exploded[1];
if (Valid::alpha()->length($min)->Validate($_POST[$name]) == false) {
$errors[] = $name . " must be at least " . $exploded[1] . " characters long!";
}
break;
case 'email':
if (Valid::email()->validate($_POST[$name]) == false) {
$errors[] = $name . " must be a valid email address!";
}
break;
case 'equalTo':
if (Valid::equals($_POST[$name])->validate($_POST[$exploded[1]]) == false) {
$errors[] = $name . "'s don't match!";
}
break;
default:
$errors[] = "No value found!";
break;
}
}
}
return $errors;
}
/**
* init valid rule
*/
protected function initRule()
{
$this->validRule['id'] = v::numeric();
$this->validRule['name'] = v::stringType()->length(1, 10);
$this->validRule['email'] = v::email();
$this->validRule['sex'] = v::intVal()->between(0, 1);
}
protected function preprocessValue(&$uid)
{
if (!Validator::int($uid)) {
throw new InvalidArgumentException('uid', 'type_invalid');
}
$uid = (int) $uid;
}
public function validate($data)
{
$validator = V::key('name', V::string()->length(0, 100), true)->key('email', V::email()->length(0, 200), true)->key('password', V::string()->length(0, 100), true);
try {
$validator->assert($data);
switch ($data['userable_type']) {
case 'Designer':
$this->designerCreationValidator->validate($data);
$data['userable_type'] = DesignerModel::class;
break;
case 'Administrator':
$this->adminCreationValidator->validate($data);
$data['userable_type'] = AdministratorModel::class;
break;
case 'Buyer':
$this->buyerCreationValidator->validate($data);
$data['userable_type'] = BuyerModel::class;
break;
default:
break;
}
} catch (AbstractNestedException $e) {
$errors = $e->findMessages(['email', 'length', 'in']);
throw new ValidationException('Could not create user.', $errors);
}
return true;
}
public function index($params)
{
Validator::notEmpty()->setName('name')->check($params['name']);
Validator::notEmpty()->setName('password')->check($params['password']);
$levels = Config::loadData('level');
$this->render('index.php', ['name' => $params['name']]);
}
public function validate($prop, $label)
{
$value = $this->getValue($prop);
if (!v::string()->notEmpty()->validate($value)) {
$this->addException("O campo {$label} é de preenchimento obrigatório");
}
}
/**
* Saves a setting as a key/value pair
*
* Settings specific to fast-forward start with a `ff.` prefix.
*
* You can use the constants of this class to avoid looking up the key names.
*
* @param string $key Unique key name.<br>
* Must contain only letters (a-z, A-Z), digits (0-9) and "."
* @param string $value
*
* @throws \Exception
*/
public function set($key, $value)
{
$out = $this->client->getOutput();
try {
v::string()->alnum('.')->noWhitespace()->notEmpty()->assert($key);
} catch (NestedValidationExceptionInterface $e) {
$out->error($e->getFullMessage());
return;
}
$setting = $this->get($key, true);
if ($setting === null) {
$setting = new Setting();
$setting->key = $key;
}
$oldValue = $setting->value;
$setting->value = $value;
if (!$this->validate($setting)) {
return;
}
if ($oldValue === null) {
$out->writeln("Inserting new setting:\n{$key} = <options=bold>{$value}</>");
} elseif ($oldValue !== $value) {
$out->writeln("Changing setting:\n{$key} = {$oldValue} --> <options=bold>{$value}</>");
} else {
$out->writeln("Setting already up-to-date:\n{$key} = {$value}");
}
$setting->save();
}
/**
* @param string $category
* @param string|null $subCategory
* @throws InvalidArgumentException
* @throws UserException
*/
public function __construct($category, $subCategory = null)
{
if (!is_string($category)) {
throw new InvalidArgumentException('category', 'type_invalid');
}
if (!mb_check_encoding($category, 'UTF-8')) {
throw new InvalidArgumentException('category', 'encoding_invalid');
}
if (!Validator::length(VJ::TAG_MIN, VJ::TAG_MAX)->validate($category)) {
throw new UserException('Problem.Tag.invalid_length');
}
$keyword = KeywordFilter::isContainGeneric($category);
if ($keyword !== false) {
throw new UserException('Problem.Tag.name_forbid', ['keyword' => $keyword]);
}
if (!is_string($subCategory)) {
throw new InvalidArgumentException('subCategory', 'type_invalid');
}
if (!mb_check_encoding($subCategory, 'UTF-8')) {
throw new InvalidArgumentException('subCategory', 'encoding_invalid');
}
if (!Validator::length(VJ::TAG_MIN, VJ::TAG_MAX)->validate($subCategory)) {
throw new UserException('Problem.Tag.invalid_length');
}
$keyword = KeywordFilter::isContainGeneric($subCategory);
if ($keyword !== false) {
throw new UserException('Problem.Tag.name_forbid', ['keyword' => $keyword]);
}
$this->category = $category;
$this->subCategory = $subCategory;
}
public function __construct($webapiKey = null, $userLogin = null, $hashedPassword = null)
{
$this->properties['webapiKey'] = new Property(['validator' => function ($value) {
try {
Validator::string()->noWhitespace()->notEmpty()->length(4)->assert($value);
} catch (NestedValidationExceptionInterface $e) {
throw new ValidationException($e);
}
}]);
if (!is_null($webapiKey)) {
$this->properties['webapiKey']->set($webapiKey)->lock();
}
// --------------------
$this->properties['userLogin'] = new Property(['validator' => function ($value) {
try {
Validator::string()->noWhitespace()->notEmpty()->length(4)->assert($value);
} catch (NestedValidationExceptionInterface $e) {
throw new ValidationException($e);
}
}]);
if (!is_null($userLogin)) {
$this->properties['userLogin']->set($userLogin)->lock();
}
// ----------------------
$this->properties['hashedPassword'] = new Property(['validator' => function ($value) {
try {
Validator::string()->noWhitespace()->notEmpty()->regex('/^([A-Za-z0-9+\\/]{4})*([A-Za-z0-9+\\/]{4}|[A-Za-z0-9+\\/]{3}=|[A-Za-z0-9+\\/]{2}==)$/')->assert($value);
} catch (NestedValidationExceptionInterface $e) {
throw new ValidationException($e);
}
}]);
if (!is_null($hashedPassword)) {
$this->properties['hashedPassword']->set($hashedPassword)->lock();
}
}
/**
* @param $param
* @return string
* @throws EntityValidationException
*/
public function password($param)
{
if (!v::notEmpty()->length(2, 100)->validate($param)) {
throw new EntityValidationException('User', 'password', $param, 'length must be between 2 and 100');
}
return $param;
}
public function post()
{
try {
$newManufacturer = (object) (['id' => null] + $_POST);
v::arr()->key('name', v::string()->notEmpty()->length(1, 300))->assert($_POST);
if ($_FILES['files']['error'] == 4) {
throw new Exception('O campo imagem é obrigatório');
}
if (empty($newManufacturer->manufacturer_featured)) {
$newManufacturer->manufacturer_featured = null;
}
$this->collection->persist($newManufacturer);
$this->collection->flush();
foreach ($_FILES as $file) {
$this->uploaderService->setFile($_POST['name'], 'files');
$image = (object) ['name' => $this->uploaderService->getFile()->getNameWithExtension(), 'title' => $_POST['name'], 'type' => $this->uploaderService->getFile()->getMimetype(), 'manufacturer_id' => $newManufacturer->id];
$this->imageCollection->persist($image);
$this->imageCollection->flush();
$this->uploaderService->upload();
}
header('HTTP/1.1 303 See Other');
header('Location: /catalog/manufacturers');
} catch (NestedValidationExceptionInterface $e) {
return $this->get() + ['manufacturer/addManufacturer' => $newManufacturer, 'messages' => $e->findMessages(['name' => 'O nome deve ser entre 1 e 300 caracteres'])];
}
}
public function testValidatorWithFilterGroups()
{
$allOfFilter = new AllOfFilter([new ClosureFilter('name', v::intVal()), v::key('key', v::regex('/test.+/i'))]);
static::assertTrue($allOfFilter->matches(['name' => '1234', 'key' => 'test47382']));
static::assertFalse($allOfFilter->matches(['name' => 'test', 'key' => 'test47382']));
static::assertFalse($allOfFilter->matches(['name' => '1234', 'key' => 'test']));
}
public function isValid($validation_data)
{
$errors = [];
foreach ($validation_data as $name => $value) {
$rules = explode("|", $value);
foreach ($rules as $rule) {
$exploded = explode(":", $rule);
switch ($exploded[0]) {
case 'min':
$min = $exploded[1];
if (Valid::stringType()->length($min, null)->Validate($_REQUEST[$name]) == false) {
$errors[] = $name . " must be at least " . $min . " characters long!";
}
break;
case 'email':
if (Valid::email()->Validate($_REQUEST[$name]) == false) {
$errors[] = $name . " must be a valid email address!";
}
break;
case 'equalTo':
if (Valid::equals($_REQUEST[$name])->Validate($_REQUEST[$exploded[1]]) == false) {
$errors[] = "Value does not match verification value!";
}
break;
default:
$errors[] = "No value found!";
}
}
}
return $errors;
}
public function post($manufacturerId)
{
$editManufacturer = $this->collection[$manufacturerId]->fetch() ?: new stdClass();
foreach ($_POST as $k => $v) {
$editManufacturer->{$k} = $v;
}
try {
v::object()->attribute('name', v::string()->notEmpty()->length(1, 300))->assert($editManufacturer);
$this->collection->persist($editManufacturer);
$this->collection->flush();
if (empty($newManufacturer->manufacturer_featured)) {
$newManufacturer->manufacturer_featured = null;
}
if ($_FILES['files']['error'] != 4) {
foreach ($_FILES as $file) {
$this->uploaderService->setFile($editManufacturer->name, 'files');
$image = (object) ['name' => $this->uploaderService->getFile()->getNameWithExtension(), 'title' => $editManufacturer->name, 'type' => $this->uploaderService->getFile()->getMimetype(), 'manufacturer_id' => $editManufacturer->id];
$this->imageCollection->persist($image);
$this->imageCollection->flush();
$this->uploaderService->upload();
}
}
header('HTTP/1.1 303 See Other');
header('Location: ' . $_SERVER['REQUEST_URI']);
} catch (NestedValidationExceptionInterface $e) {
return ['editManufacturer' => $editManufacturer, 'messages' => $e->findMessages(['name' => 'Name must have between 1 and 300 chars', 'enabled' => 'Could not enable manufacturer'])];
}
}
public function setJustification($justification)
{
if (!v::string()->length(15, 1000)->validate($justification)) {
throw new FieldRequiredException("A justicativa deve ter entre 15 e 100 caracteres");
}
$this->_justification = $justification;
}
/**
* 创建并返回一个 token
*
* @param string $purpose
* @param string|null $identifier 唯一标识，为空则不需要
* @param int $expireAt
* @param mixed $data
* @param int $length
* @return array
* @throws InvalidArgumentException
* @throws \Exception
* @throws \MongoException
*/
public function generate($purpose, $identifier, $expireAt, $data = null, $length = 30)
{
if (!is_string($purpose)) {
throw new InvalidArgumentException('purpose', 'type_invalid');
}
if (!mb_check_encoding($purpose, 'UTF-8')) {
throw new InvalidArgumentException('purpose', 'encoding_invalid');
}
if (!Validator::int()->validate($expireAt)) {
throw new InvalidArgumentException('expireAt', 'type_invalid');
}
$token = Application::get('random')->generateString($length, VJ::RANDOM_CHARS);
try {
if ($identifier !== null) {
if (!is_string($identifier)) {
throw new InvalidArgumentException('identifier', 'type_invalid');
}
if (!mb_check_encoding($identifier, 'UTF-8')) {
throw new InvalidArgumentException('identifier', 'encoding_invalid');
}
$result = Application::coll('Token')->update(['purpose' => $purpose, 'identifier' => $identifier], ['$set' => ['token' => $token, 'expireat' => new \MongoDate($expireAt), 'data' => $data]], ['upsert' => true]);
return ['token' => $token, 'update' => $result['updatedExisting']];
} else {
$result = Application::coll('Token')->insert(['purpose' => $purpose, 'identifier' => null, 'token' => $token, 'expireat' => new \MongoDate($expireAt), 'data' => $data]);
return ['token' => $token];
}
} catch (\MongoException $ex) {
if ($ex->getCode() === 12) {
throw new InvalidArgumentException('data', 'encoding_invalid');
} else {
throw $ex;
}
}
}
function OrderTable($ordersProducts, $connection)
{
foreach ($ordersProducts as $arrayNumber => $orders_data) {
echo "<tr class='product'>";
foreach ($orders_data as $data_key => $data_value) {
//echo "data-key: ".$data_key." data-value: ".$data_value."<br>";
switch ($data_key) {
case "product_id":
$product = \App\DB\Products::get($data_value, $connection);
$flag = v::arr()->notEmpty()->validate($product);
if ($flag) {
printProduct($product);
} else {
echo "<td class='deleted-product' colspan='2'>Товар удален из базы данных</td>";
}
break;
case "amount":
echo "<td data-amount='{$data_value}'>" . $data_value . "</td></tr>";
break;
default:
break;
}
}
}
}
/**
* 加入域
*
* @param int $uid
* @param \MongoId $domainId
* @return bool
* @throws InvalidArgumentException
* @throws UserException
*/
public function joinDomainById($uid, \MongoId $domainId)
{
if (!Validator::int()->validate($uid)) {
throw new InvalidArgumentException('uid', 'type_invalid');
}
$uid = (int) $uid;
if (!DomainUtil::isGlobalDomainId($domainId)) {
// 检查域是否存在
$d = Application::coll('Domain')->findOne(['_id' => $domainId]);
if (!DomainUtil::isDomainObjectValid($d)) {
throw new UserException('DomainManager.joinDomain.invalid_domain');
}
}
// 检查用户是否存在
$user = UserUtil::getUserObjectByUid($uid);
if (!UserUtil::isUserObjectValid($user)) {
throw new UserException('DomainManager.joinDomain.invalid_user');
}
// 添加 MEMBER 角色
Application::coll('UserRole')->update(['uid' => $uid], ['$addToSet' => ['d.' . (string) $domainId => 'DOMAIN_MEMBER']], ['upsert' => true]);
// 创建空资料
$document = ['pref' => new \stdClass(), 'rp' => 0.0, 'rp_s' => 0.0, 'rank' => -1, 'level' => 0];
if (DomainUtil::isGlobalDomainId($domainId)) {
$document += ['sig' => '', 'sigraw' => '', 'contacts' => []];
}
Application::coll('UserInfo')->update(['uid' => $uid, 'domain' => new \MongoId(VJ::DOMAIN_GLOBAL)], ['$setOnInsert' => $document], ['upsert' => true]);
// 操作非全局域则插入操作记录
if (!DomainUtil::isGlobalDomainId($domainId)) {
$doc = ['uid' => $this->session->getCurrentToken(), 'at' => new \MongoDate(), 'type' => 'join', 'ua' => $this->request->getUserAgent(), 'ip' => $this->request->getClientIp(), 'target_uid' => $uid, 'target_domain' => $domainId];
Application::coll('DomainLog')->insert($doc);
}
return true;
}
public function validate($prop, $label)
{
$v = $this->getValue($prop);
if (!v::min($this->_min, true)->max($this->_max, true)->validate($v)) {
$this->addException("O campo {$label} deve conter um número entre {$this->_min} e {$this->_max}");
}
}