src/Util/EntityUtil.php line 138

1. <?php
3. namespace EADPlataforma\Util;
5. use Doctrine\ORM\EntityManagerInterface;
6. use Symfony\Component\Validator\Validator\ValidatorInterface;
7. use Symfony\Component\Serializer\Encoder\JsonEncoder;
8. use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
9. use Symfony\Component\Serializer\Serializer;
10. use EADPlataforma\Services\GeneralService;
11. use \ReflectionClass;
12. use \ReflectionProperty;
13. use \Exception;
15. class EntityUtil{
17.     /**
18.      *
19.      * @var Entity
20.      *
21.      */
22.     private $entity;
24.     /**
25.      * @var SchoolEntityManager
26.      */
27.     protected $em;
29.     /**
30.      *
31.      * @var ValidatorInterface $validator
32.      *
33.      */
34.     private $validator;
36.     /**
37.      * Constructor
38.      *
39.      * @param GeneralService $generalService
40.      * @param ValidatorInterface $validator
41.      */
42.     public function __construct(GeneralService $generalService, ValidatorInterface $validator)
43.     {
44.         $this->em = $generalService->getService('SchoolEntityManager');
45.         $this->validator = $validator;
46.     }
48.     public function setEntity($entity)
49.     {
51.         $this->entity = $entity;
53.         return $this;
54.     }
56.     public function json() {
57.         if($this->entity){
58.             $encoders = [new JsonEncoder()];
59.             $normalizers = [new ObjectNormalizer()];
60.             $serializer = new Serializer($normalizers, $encoders);
62.             $jsonContent = $serializer->serialize($this->entity, 'json', [
63.                 'circular_reference_handler' => function ($object) {
64.                     return $object->getId();
65.                 }
66.             ]);
68.             return $jsonContent;
69.         }else{
70.             throw new Exception("Entity not found", 1);
71.         }
72.     }
74.     public function getClassName($onlyName = false)
75.     {
76.         if($this->entity){
77.             $className = get_class($this->entity);
78.             
79.             if($onlyName){
80.                 $className = explode("\\", $className);
81.                 $className = end($className);
82.             }
84.             return $className;
85.         }else{
86.             throw new Exception("Entity not found", 1);
87.         }
88.     }
90.     public function getTableName()
91.     {
92.         if($this->entity){
93.             return $this->em->getClassMetadata($this->getClassName())->getTableName();
94.         }else{
95.             throw new Exception("Entity not found", 1);
96.         }
97.     }
99.     public function getFieldsName()
100.     {
101.         if($this->entity){
102.             $reflection = new ReflectionClass($this->entity);
103.             $entityProperties = $reflection->getProperties(ReflectionProperty::IS_PRIVATE);
104.             $fields = [];
105.             foreach ($entityProperties as $key => $property) {
106.                 $propName = $property->getName();
107.                 $fields[] = $propName;
108.             }
110.             return $fields;
111.         }else{
112.             throw new Exception("Entity not found", 1);
113.         }
114.     }
116.     public function setAllFields(array $data)
117.     {
118.         if($this->entity){
119.             foreach ($data as $property => $value) {
120.                 if (property_exists($this->entity, $property)) {
121.                     $setFunc = "set" . ucfirst($property);
122.                     if(method_exists($this->entity, $setFunc)){
123.                         $this->entity->{$setFunc}($value);
124.                     }
125.                 }
126.             }
128.             return $this->entity;
129.         }else{
130.             throw new Exception("Entity not found", 1);
131.         }
132.     }
134.     public function validateEntity($groups = [])
135.     {
136.         $groups[] = "Default";
138.         $errors = $this->validator->validate($this->entity, null, $groups);
139.         if (count($errors) > 0) {
140.             $fields = [];
141.             
142.             $className = $this->getClassName(true);
144.             foreach ($errors as $violation) {
145.                 $fieldName = $violation->getPropertyPath();
147.                 $fieldArray = explode('.', $fieldName);
149.                 if(count($fieldArray) == 1){
150.                     $fieldName = array_shift($fieldArray);
151.                     $fields[] = $fieldName;
152.                 }
153.             }
155.             $fields = array_unique($fields);
156.             sort($fields);
158.             return $fields;
159.         }
161.         return false;
162.     }
163. }