src/Validator/Validator.php line 54

Open in your IDE?
  1. <?php
  2. namespace App\Validator;
  3. use Symfony\Component\Validator\Constraints as Assert;
  4. use Symfony\Component\PropertyAccess\PropertyAccess;
  5. use Symfony\Component\Validator\Validator\ValidatorInterface;
  6. use App\Validator\ContainsWhitespace;
  7. use App\Validator\ContainsIsArray;
  8. use App\Validator\ContainsUniqueInClass;
  9. use App\Validator\ContainsExistValueInClass;
  10. use App\Validator\ContainsChoiceArray;
  11. use App\Validator\ContainsArrayList;
  12. // use Digicore\EcommerceBundle\Repo\ProductRepo;
  13. class Validator
  14. {
  15.     public $validator;
  16.     public function __construct(ValidatorInterface $validator)
  17.     {
  18.         $this->validator $validator;    
  19.     }
  20.     public function validate(array $parameters$request)
  21.     {
  22.         $errorMessages null;
  23.         $constraintsArray = [];
  24.         $violationsArray = [];
  25.         foreach ($parameters as $key => $param) {
  26.             $violationsArray[$key] = !is_array($request->get($key))?trim($request->get($key)):$request->get($key);
  27.             $constraintsArray[$key] = [];
  28.             $arrayParam explode('|'$param);
  29.             foreach ($arrayParam as $node) {
  30.                 $arrNode explode(':'$node); 
  31.                 $functionName $arrNode[0];
  32.                 if($functionName == 'image' || $functionName == 'imageArray' || $functionName == 'imageArrayRequired'
  33.                 || $functionName == 'file' || $functionName == 'fileArray'){
  34.                     $violationsArray[$key] = $request->files->get($key);
  35.                 }
  36.                 if (method_exists($this$functionName)){
  37.                     array_push($constraintsArray[$key], $this->$functionName($key, isset($arrNode[1]) ? $arrNode[1] : null));   
  38.                 } 
  39.             }
  40.         }
  41.         $constraints = new Assert\Collection(['fields' => $constraintsArray]);
  42.         $violations $this->validator->validate($violationsArray$constraints);
  43.         if (count($violations) > 0) {
  44.             $accessor PropertyAccess::createPropertyAccessor();
  45.             foreach ($violations as $violation) {
  46.                 $errorMessages $violation->getMessage();
  47.                 break;
  48.             }
  49.            
  50.         }
  51.         return $errorMessages;
  52.     }
  53.     function required($key$params null){
  54.         return new Assert\NotBlank(
  55.             ["message" => 'validate.required.'.$key]
  56.         );
  57.     }
  58.     function email($key$params null){
  59.         
  60.         return new Assert\Email(
  61.             ["message" => 'validate.email']
  62.         );
  63.     }
  64.     function length($key$params null){
  65.         $options = [
  66.             "minMessage" => 'validate.length.min.'.$key,
  67.             "maxMessage" => 'validate.length.max.'.$key
  68.         ];
  69.         
  70.         if($params){
  71.             $arrParam explode(','$params);
  72.             foreach ($arrParam as $key => $value) {
  73.                 if( ($key 2) == ){
  74.                     $options[$value] = $arrParam[($key 1)];
  75.                 }
  76.             }
  77.         }
  78.         return new Assert\Length($options);
  79.     }
  80.     // function exists($key, $params = null){
  81.     //     if ($params) {
  82.     //         $arrParam = explode(',', $params);
  83.     //         $options = [
  84.     //             "message" => 'validate.class.by.'.$arrParam[1].'.'.$arrParam[0],
  85.     //             "class" => $arrParam[0],
  86.     //             "field" => $arrParam[1],
  87.     //             "value" => $arrParam[2]
  88.     //         ];
  89.     //     }
  90.     //     return new ContainsClassByField($options);
  91.     // }
  92.     function choice($key$params null){
  93.         $options = [
  94.             "message" => 'validate.choice.'.$key,
  95.         ];
  96.         
  97.         if($params){
  98.             $arrParam explode(','$params);
  99.             $options["choices"] = $arrParam;
  100.         }
  101.         
  102.         return new Assert\Choice($options);
  103.     }
  104.     function positive($key$params null){
  105.         $options = [
  106.             "message" => 'validate.positive.'.$key,
  107.         ];
  108.         return new Assert\Positive($options);
  109.     }
  110.     function numeric($key$params null){
  111.         $options = [
  112.             "type" => 'numeric',
  113.             "message" => 'validate.numeric.'.$key,
  114.         ];
  115.         return new Assert\Type($options);
  116.     }
  117.     function count($key$params null){
  118.         $options = [
  119.             "minMessage" => 'validate.count.min.'.$key,
  120.             "maxMessage" => 'validate.count.max.'.$key,
  121.             "exactMessage" => 'validate.count.exact.'.$key,
  122.         ];
  123.         if($params){
  124.             $arrParam explode(','$params);
  125.             foreach ($arrParam as $key => $value) {
  126.                 if( ($key 2) == ){
  127.                     $options[$value] = $arrParam[($key 1)];
  128.                 }
  129.             }
  130.         }
  131.         return new Assert\Count($options);
  132.     }
  133.     function image($key$params null){
  134.         $options = [
  135.             "maxSizeMessage" => 'validate.image.maxSize.'.$key,
  136.             "mimeTypesMessage" => 'validate.image.mimeTypes.'.$key
  137.         ];
  138.         if($params){
  139.             $arrParam explode(','$params);
  140.             foreach ($arrParam as $key => $value) {
  141.                 if( ($key 2) == ){
  142.                     if($value == "mimeTypes"){
  143.                         $options[$value] = explode("#"$arrParam[($key 1)]);
  144.                     }else{
  145.                         $options[$value] = $arrParam[($key 1)];
  146.                     }
  147.                     
  148.                 }
  149.             }
  150.         }
  151.         return new Assert\Image($options);
  152.     }
  153.     function array($key){
  154.         $options = [
  155.             'type' => 'array',
  156.             'message' => 'validate.'.$key.'.is.{{ type }}',
  157.         ];
  158.         return new Assert\Type($options);
  159.     }
  160.     function string($key){
  161.         $options = [
  162.             'type' => 'string',
  163.             'message' => 'validate.'.$key.'.is.{{ type }}',
  164.         ];
  165.         return new Assert\Type($options);
  166.     }
  167.     function alnum($key){
  168.         $options = [
  169.             'type' => 'alnum',
  170.             'message' => 'validate.'.$key.'.is.{{ type }}',
  171.         ];
  172.         return new Assert\Type($options);
  173.     }
  174.     function imageArray($keyName$params null){
  175.         $options = [
  176.             "maxSizeMessage" => 'validate.image.maxSize.'.$keyName,
  177.             "mimeTypesMessage" => 'validate.image.mimeTypes.'.$keyName
  178.         ];
  179.         if($params){
  180.             $arrParam explode(','$params);
  181.             foreach ($arrParam as $key => $value) {
  182.                 if( ($key 2) == ){
  183.                     if($value == "mimeTypes"){
  184.                         $options[$value] = explode("#"$arrParam[($key 1)]);
  185.                     }else{
  186.                         $options[$value] = $arrParam[($key 1)];
  187.                     }
  188.                     
  189.                 }
  190.             }
  191.         }
  192.         return new Assert\All([new Assert\Image($options)]);
  193.     }
  194.     function fileArray($keyName$params null){
  195.         $options = [
  196.             "maxSizeMessage" => 'validate.image.maxSize.'.$keyName,
  197.             "mimeTypesMessage" => 'validate.image.mimeTypes.'.$keyName
  198.         ];
  199.         if($params){
  200.             $arrParam explode(','$params);
  201.             foreach ($arrParam as $key => $value) {
  202.                 if( ($key 2) == ){
  203.                     if($value == "mimeTypes"){
  204.                         $options[$value] = explode("#"$arrParam[($key 1)]);
  205.                     }else{
  206.                         $options[$value] = $arrParam[($key 1)];
  207.                     }
  208.                     
  209.                 }
  210.             }
  211.         }
  212.         return new Assert\All([new Assert\File($options)]);
  213.     }
  214.     function file($key$params null){
  215.         
  216.         $options = [
  217.             "maxSizeMessage" => 'validate.image.maxSize.'.$key,
  218.             "mimeTypesMessage" => 'validate.image.mimeTypes.'.$key
  219.         ];
  220.         if($params){
  221.             // dd($key, $params);
  222.             $arrParam explode(','$params);
  223.             foreach ($arrParam as $key => $value) {
  224.                 if( ($key 2) == ){
  225.                     if($value == "mimeTypes"){
  226.                         $options[$value] = explode("#"$arrParam[($key 1)]);
  227.                     }else{
  228.                         $options[$value] = $arrParam[($key 1)];
  229.                     }
  230.                     
  231.                 }
  232.             }
  233.         }
  234.         return new Assert\File($options);
  235.     }
  236.     function date($key$params null){
  237.         
  238.         return new Assert\Date(
  239.             ["message" => 'validate.date.'.$key]
  240.         );
  241.     }
  242.     function confirm($key$params){
  243.         $arrParam explode(','$params);
  244.         $options = [
  245.             'message' => 'validate.confirm.'.$key,
  246.             // 'propertyPath' => $arrParam[0],
  247.             'value' => $arrParam[0]
  248.         ];
  249.         // dd(new Assert\EqualTo($options));
  250.         return new Assert\EqualTo($options);
  251.     }
  252.     function whitespace($key$params) {
  253.         $options = [
  254.             'message' => 'validate.whitespace.'.$key,
  255.         ];
  256.         return new ContainsWhitespace($options);
  257.     }
  258.     // function arrayProduct($key) {
  259.     //     $options = [
  260.     //         'fields' => [
  261.     //             'id' => [$this->required('id'), $this->existsValue('id', ProductRepo::PRODUCT_CLASS_NAME)],
  262.     //             'count' => [$this->required('count'), $this->numeric('count'), $this->positive('count')],
  263.     //         ],
  264.             
  265.     //         'missingFieldsMessage' => 'product.{{ field }}.missing'
  266.     //     ];
  267.     //     return new Assert\All([
  268.     //         new Assert\Collection($options),
  269.     //     ]);
  270.     // }
  271.     /**
  272.      * Check if value already existed in a field in a class.
  273.      * Format: unique:Class
  274.      */
  275.     function unique($key$class null) {
  276.         $options = [
  277.             'message' => 'validate.unique.'.$key,
  278.         ];
  279.         if ($class) {
  280.             $options['class'] = $class;
  281.             $options['field'] = $key;
  282.         }
  283.         return new ContainsUniqueInClass($options);
  284.     }
  285.     /**
  286.      * Check if value valid with regex expression .
  287.      * Format: regex:expression
  288.      */
  289.     function regex($key$expression null) {
  290.         return new Assert\Regex([
  291.             'message' => 'validate.regex.'.$key,
  292.             'pattern' => '/'$expression '/'
  293.         ]);
  294.     }
  295.     /**
  296.      * Check if value is valid with a field in Class
  297.      * Format: existsValue:Class<-field>
  298.      */
  299.     function existsValue($key$classField) {
  300.         $options = [
  301.             'message' => 'validate.value-not-exist.'.$key,
  302.         ];
  303.         if ($classField) {
  304.             $array explode('-'$classField);
  305.             $options['class'] = $array[0];
  306.             $options['field'] = count($array) == $array[1] : $key;
  307.         }
  308.         return new ContainsExistValueInClass($options);
  309.     }
  310.     /**
  311.      * Format: choiceArray:option1,option2
  312.      */
  313.     function choiceArray($key$params) {
  314.         $options = [
  315.             'message' => 'validate.array-value-not-valid.'.$key,
  316.         ];
  317.         $options['options'] = $params;
  318.         return new ContainsChoiceArray($options);
  319.     }
  320.     function arrayList($key$params) {
  321.         $options = [
  322.             'message' => 'validate.array-value-not-valid.'.$key,
  323.         ];
  324.         return new ContainsArrayList($options);
  325.     }
  326. }