506 lines
14 KiB
PHP
506 lines
14 KiB
PHP
<?php
|
|
|
|
namespace Bluesquare\ValidatorBundle;
|
|
|
|
use Bluesquare\StorageBundle\Exceptions\MimeTypeException;
|
|
use Bluesquare\StorageBundle\Storage;
|
|
use Symfony\Component\HttpFoundation\RequestStack;
|
|
use Symfony\Contracts\Translation\TranslatorInterface;
|
|
use Symfony\Component\HttpFoundation\JsonResponse;
|
|
|
|
class Validator
|
|
{
|
|
protected $request;
|
|
protected $context;
|
|
protected $errors;
|
|
protected $entity;
|
|
protected $values;
|
|
protected $rules;
|
|
protected $validated;
|
|
protected $translator;
|
|
|
|
public function __construct(RequestStack $requestStack, TranslatorInterface $translator)
|
|
{
|
|
$this->values = [];
|
|
$this->errors = [];
|
|
$this->rules = [];
|
|
$this->validated = false;
|
|
|
|
$this->translator = $translator;
|
|
$this->request = $requestStack->getCurrentRequest();
|
|
|
|
$session = $this->request->getSession()->getFlashBag()->get("Bluesquare:ValidatorBundle");
|
|
|
|
if(is_array($session) && isset($session[0])) {
|
|
if(isset($session[0]['context'])) $this->context = $session[0]['context'];
|
|
if(isset($session[0]['errors']) && is_array($session[0]['errors'])) $this->errors = $session[0]['errors'];
|
|
if(isset($session[0]['values']) && is_array($session[0]['values'])) $this->values = $session[0]['values'];
|
|
$this->validated = true;
|
|
}
|
|
|
|
if ($this->post())
|
|
{
|
|
$values = [];
|
|
foreach (array_merge($_GET, $_POST) as $field => $value) $values[$field] = $value;
|
|
$json = @json_decode(file_get_contents('php://input'), true);
|
|
if (is_array($json)) $values = array_merge($values, $json);
|
|
$this->values = array_merge($this->values, $values);
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
public function context($context)
|
|
{
|
|
$this->context = $context;
|
|
return $this;
|
|
}
|
|
|
|
public function entity($entity)
|
|
{
|
|
$this->entity = $entity;
|
|
return $this;
|
|
}
|
|
|
|
public function set($key, $value)
|
|
{
|
|
$this->values[$key] = $value;
|
|
return $this;
|
|
}
|
|
|
|
public function error($field, $error)
|
|
{
|
|
if (!isset($this->errors[$field]))
|
|
$this->errors[$field] = [];
|
|
|
|
$this->errors[$field][] = $error;
|
|
|
|
return $this;
|
|
}
|
|
|
|
//
|
|
|
|
public function json($code = 400, $data = [])
|
|
{
|
|
$errors = [];
|
|
|
|
foreach ($this->errors as $field => $field_errors)
|
|
{
|
|
$errors[$field] = [
|
|
'error' => "validator.".$field_errors[0].':'.$field.(!is_null($this->context) ? ':'.$this->context : '')
|
|
];
|
|
}
|
|
|
|
$data = array_merge([
|
|
'message' => 'Please check your input',
|
|
'error' => "validator.form-error".(!is_null($this->context) ? ':'.$this->context : ''),
|
|
'errors' => $errors
|
|
], $data);
|
|
|
|
return new JsonResponse($data, $code);
|
|
}
|
|
|
|
public function keep()
|
|
{
|
|
$data = [
|
|
'errors' => $this->errors,
|
|
'values' => $this->values,
|
|
'context' => $this->context
|
|
];
|
|
$this->request->getSession()->getFlashBag()->add('Bluesquare:ValidatorBundle', $data);
|
|
return $this;
|
|
}
|
|
|
|
public function validated()
|
|
{
|
|
return $this->validated;
|
|
}
|
|
|
|
public function failed()
|
|
{
|
|
return (count($this->errors) > 0);
|
|
}
|
|
|
|
public function errors()
|
|
{
|
|
$translator = $this->translator;
|
|
$context = $this->context;
|
|
|
|
return array_map(function ($errors) use ($translator, $context) {
|
|
$error = $errors[0];
|
|
$message = null;
|
|
if (!is_null($context)) {
|
|
$message = $translator->trans("$context.$error", [], "validator");
|
|
}
|
|
if (is_null($message) || $message == "$context.$error") {
|
|
$message = $translator->trans("$error", [], "validator");
|
|
}
|
|
return $message;
|
|
}, $this->errors);
|
|
}
|
|
|
|
public function message()
|
|
{
|
|
$result = $this->failed() ? 'form_error' : 'form_success';
|
|
$message = null;
|
|
if (!is_null($this->context)) {
|
|
$message = $this->translator->trans("$this->context.$result", [], "validator");
|
|
}
|
|
if (is_null($message) || $message == "$this->context.$result") {
|
|
$message = $this->translator->trans("$result", [], "validator");
|
|
}
|
|
return $message;
|
|
}
|
|
|
|
public function has($field)
|
|
{
|
|
return !is_null($this->get($field));
|
|
}
|
|
|
|
public function value($field, $default = null)
|
|
{
|
|
$value = isset($this->values[$field]) ? trim($this->values[$field]) : $default;
|
|
if (empty($value)) $value = $default;
|
|
|
|
if (is_null($value) && !is_null($this->entity)) {
|
|
$method = "get".$this->camelize($field);
|
|
if (method_exists($this->entity, $method))
|
|
$value = $this->entity->$method();
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
public function get($field, $default = null)
|
|
{
|
|
$value = isset($this->values[$field]) ? trim($this->values[$field]) : $default;
|
|
if (strlen($value) == 0) $value = $default;
|
|
return $value;
|
|
}
|
|
|
|
public function checked($field)
|
|
{
|
|
return $this->post() ? (
|
|
!is_null($this->get($field))
|
|
) : (
|
|
!is_null($this->value($field)) && $this->value($field) != 0 && $this->value($field) != false
|
|
);
|
|
}
|
|
|
|
public function isChecked($field)
|
|
{
|
|
return $this->has($field);
|
|
}
|
|
|
|
public function getFile($name)
|
|
{
|
|
return $this->request->files->get($name);
|
|
}
|
|
|
|
public function hasFile($name)
|
|
{
|
|
$file = $this->getFile($name);
|
|
return !is_null($file) && !(is_array($file) || $file instanceof Traversable);
|
|
}
|
|
|
|
public function hasFiles($name)
|
|
{
|
|
$files = $this->getFile($name);
|
|
return !is_null($files) && (is_array($files) || $files instanceof Traversable);
|
|
}
|
|
|
|
public function inject()
|
|
{
|
|
$args = func_get_args();
|
|
if (count($args) === 0) return false;
|
|
if (is_object($args[0])) $entity = array_shift($args);
|
|
else $entity = $this->entity;
|
|
if (is_null($entity)) return false;
|
|
|
|
foreach ($args as $field) {
|
|
$method = "set".$this->camelize($field);
|
|
if (method_exists($entity, $method)) $entity->$method($this->get($field));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function injectFile()
|
|
{
|
|
$args = func_get_args();
|
|
if (count($args) === 0) return false;
|
|
if (is_object($args[0])) $entity = array_shift($args);
|
|
else $entity = $this->entity;
|
|
|
|
if (is_null($entity) || count($args) != 2) return false;
|
|
$attribute = $args[0];
|
|
$storage = $args[1];
|
|
|
|
if (!$this->hasFile($attribute))
|
|
{
|
|
$this->error($attribute, 'required');
|
|
return false;
|
|
}
|
|
|
|
if ($storage instanceof Storage)
|
|
{
|
|
try {
|
|
return $storage->store($entity, $attribute, $this->getFile($attribute));
|
|
}
|
|
catch(MimeTypeException $exception) {
|
|
$this->error($attribute, 'file_mime_type');
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
public function post()
|
|
{
|
|
return in_array(strtolower($this->request->getMethod()), ['delete', 'put', 'post', 'patch']);
|
|
}
|
|
|
|
public function check()
|
|
{
|
|
return $this->validate();
|
|
}
|
|
|
|
//
|
|
|
|
protected function validate()
|
|
{
|
|
foreach ($this->rules as $field => $rules)
|
|
{
|
|
$rules_names = array_map(function($rule) { return $rule['rule']; }, $rules);
|
|
$nullable = !in_array('required', $rules_names) && !in_array('required_file', $rules_names) && !in_array('required_files', $rules_names);
|
|
foreach ($rules as $rule) $this->test($field, $rule, $nullable);
|
|
}
|
|
|
|
$this->validated = true;
|
|
|
|
return (count($this->errors) == 0);
|
|
}
|
|
|
|
public function test($field, $rule, $nullable = false)
|
|
{
|
|
$name = $rule['rule'];
|
|
$data = $rule['data'];
|
|
$value = $this->get($field);
|
|
$success = true;
|
|
|
|
switch ($name)
|
|
{
|
|
case 'required_file':
|
|
$success = $this->hasFile($field);
|
|
break;
|
|
case 'required_files':
|
|
$success = $this->hasFiles($field);
|
|
break;
|
|
case 'required':
|
|
$success = !(is_null($value));
|
|
break;
|
|
case 'integer':
|
|
$success = (filter_var($value, FILTER_VALIDATE_INT) !== false);
|
|
break;
|
|
case 'float':
|
|
$success = (filter_var($value, FILTER_VALIDATE_FLOAT) !== false);
|
|
break;
|
|
case 'boolean':
|
|
$success = (filter_var($value, FILTER_VALIDATE_BOOLEAN) !== false);
|
|
break;
|
|
case 'email':
|
|
$success = (filter_var($value, FILTER_VALIDATE_EMAIL) !== false);
|
|
break;
|
|
case 'phone':
|
|
$_pattern = "/^\+?\d{7,15}$/";
|
|
$success = (!(strlen($value) == 10 && ctype_digit($value)) && !preg_match($_pattern, $value)) ? false : true;
|
|
break;
|
|
case 'zipcode':
|
|
$success = (!(strlen($value) == 5 && ctype_digit($value))) ? false : true;
|
|
break;
|
|
case 'alphanumeric':
|
|
$success = ctype_alnum($value);
|
|
break;
|
|
case 'date':
|
|
$success = preg_match('/^([0-9]{2}\/[0-9]{2}\/[0-9]{4})|([0-9]{4}-[0-9]{2}-[0-9]{2})$/', $value);
|
|
break;
|
|
case 'datetime':
|
|
$_pattern = "[0-9]{4}\-[0-9]{2}\-[0-9]{2}\ [0-9]{1,2}\:[0-9]{1,2}\:[0-9]{1,2}";
|
|
$success = (preg_match($_pattern, $value)) ? true : false;
|
|
break;
|
|
case 'url':
|
|
$_pattern = "%^((?:(?:https?|ftp)://))?(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\x{00a1}-\x{ffff}0-9]-*)*[a-z\x{00a1}-\x{ffff}0-9]+)(?:\.(?:[a-z\x{00a1}-\x{ffff}0-9]-*)*[a-z\x{00a1}-\x{ffff}0-9]+)*(?:\.(?:[a-z\x{00a1}-\x{ffff}]{2,}))\.?)(?::\d{2,5})?(?:[/?#]\S*)?$%iuS";
|
|
$success = preg_match($_pattern, $value);
|
|
break;
|
|
case 'in_array':
|
|
$success = in_array($value, $data['values']);
|
|
break;
|
|
case 'min':
|
|
$success = min($value, $data['length']) == $value ? true : false;
|
|
break;
|
|
case 'max':
|
|
$success = max($value, $data['length']) == $value ? true : false;
|
|
break;
|
|
case 'min_length':
|
|
$success = strlen($value) >= $data['length'] ? true : false;
|
|
break;
|
|
case 'max_length':
|
|
$success = strlen($value) <= $data['length'] ? true : false;
|
|
break;
|
|
case 'identical':
|
|
$success = $value == $this->get($data['target']);
|
|
break;
|
|
// (éwé c'est un switch)
|
|
}
|
|
|
|
if (!$success)
|
|
{
|
|
if ($nullable && empty($value))
|
|
return true;
|
|
|
|
$this->error($field, $name);
|
|
}
|
|
|
|
return $success;
|
|
}
|
|
|
|
public function rule($field, $rule, $data = [])
|
|
{
|
|
if (!isset($this->rules[$field]))
|
|
$this->rules[$field] = [];
|
|
|
|
$this->rules[$field][] = ['rule' => $rule, 'data' => $data];
|
|
|
|
return $this;
|
|
}
|
|
|
|
// Rules: multiple
|
|
|
|
public function required()
|
|
{
|
|
foreach (func_get_args() as $field) $this->rule($field, 'required');
|
|
return $this;
|
|
}
|
|
|
|
public function integer()
|
|
{
|
|
foreach (func_get_args() as $field) $this->rule($field, 'integer');
|
|
return $this;
|
|
}
|
|
|
|
public function float()
|
|
{
|
|
foreach (func_get_args() as $field) $this->rule($field, 'float');
|
|
return $this;
|
|
}
|
|
|
|
public function boolean()
|
|
{
|
|
foreach (func_get_args() as $field) $this->rule($field, 'boolean');
|
|
return $this;
|
|
}
|
|
|
|
public function email()
|
|
{
|
|
foreach (func_get_args() as $field) $this->rule($field, 'email');
|
|
return $this;
|
|
}
|
|
|
|
public function phone()
|
|
{
|
|
foreach (func_get_args() as $field) $this->rule($field, 'phone');
|
|
return $this;
|
|
}
|
|
|
|
public function zipcode()
|
|
{
|
|
foreach (func_get_args() as $field) $this->rule($field, 'zipcode');
|
|
return $this;
|
|
}
|
|
|
|
public function alphanumeric()
|
|
{
|
|
foreach (func_get_args() as $field) $this->rule($field, 'alphanumeric');
|
|
return $this;
|
|
}
|
|
|
|
public function date()
|
|
{
|
|
foreach (func_get_args() as $field) $this->rule($field, 'date');
|
|
return $this;
|
|
}
|
|
|
|
public function datetime()
|
|
{
|
|
foreach (func_get_args() as $field) $this->rule($field, 'datetime');
|
|
return $this;
|
|
}
|
|
|
|
public function url()
|
|
{
|
|
foreach (func_get_args() as $field) $this->rule($field, 'url');
|
|
return $this;
|
|
}
|
|
|
|
// Rules: single
|
|
|
|
public function requiredFile($name)
|
|
{
|
|
$this->rule($name, 'required_file');
|
|
return $this;
|
|
}
|
|
|
|
public function requiredFiles($name)
|
|
{
|
|
$this->rule($name, 'required_files');
|
|
return $this;
|
|
}
|
|
|
|
public function min($field, $length)
|
|
{
|
|
$this->rule($field, 'min', ['length' => $length]);
|
|
return $this;
|
|
}
|
|
|
|
public function max($field, $length)
|
|
{
|
|
$this->rule($field, 'max', ['length' => $length]);
|
|
return $this;
|
|
}
|
|
|
|
public function minLength($field, $length)
|
|
{
|
|
$this->rule($field, 'min_length', ['length' => $length]);
|
|
return $this;
|
|
}
|
|
|
|
public function maxLength($field, $length)
|
|
{
|
|
$this->rule($field, 'max_length', ['length' => $length]);
|
|
return $this;
|
|
}
|
|
|
|
public function inArray($field, $values)
|
|
{
|
|
$this->rule($field, 'in_array', ['values' => $values]);
|
|
return $this;
|
|
}
|
|
|
|
public function identical($field, $field_confirm)
|
|
{
|
|
$this->rule($field_confirm, 'identical', ['target' => $field]);
|
|
return $this;
|
|
}
|
|
|
|
// Helpers
|
|
|
|
protected function camelize($string)
|
|
{
|
|
$string = implode('_', explode('-', $string));
|
|
$words = array_map('ucfirst', explode('_', $string));
|
|
return implode('', $words);
|
|
}
|
|
}
|