src/Entity/EntityLog.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Enum\EntityLog\Type;
  6. use App\Repository\EntityLogRepository;
  7. use App\Service\EntityService;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * @ORM\Entity(repositoryClass=EntityLogRepository::class)
  12.  */
  13. class EntityLog
  14. {
  15.     /**
  16.      * @ORM\Id
  17.      * @ORM\GeneratedValue
  18.      * @ORM\Column(type="integer")
  19.      */
  20.     private $id;
  22.     /**
  23.      * @ORM\Column(type="string", length=255)
  24.      */
  25.     private $entityClass;
  27.     /**
  28.      * @ORM\Column(type="enum", options={"values"="entity_log_enum", "default"="update"})
  29.      */
  30.     private $type = Type::TYPE_UPDATE;
  32.     /**
  33.      * @ORM\Column(type="datetime")
  34.      */
  35.     private $createdAt;
  37.     /**
  38.      * @ORM\Column(type="string", length=255, nullable=true)
  39.      */
  40.     private $fieldName;
  42.     /**
  43.      * @ORM\Column(type="text", nullable=true)
  44.      */
  45.     private $oldValue;
  47.     /**
  48.      * @ORM\Column(type="text", nullable=true)
  49.      */
  50.     private $newValue;
  52.     /**
  53.      * @ORM\Column(type="integer", nullable=true)
  54.      */
  55.     private $entityId;
  57.     /**
  58.      * @ORM\ManyToOne(targetEntity=User::class)
  59.      * @ORM\JoinColumn(nullable=true)
  60.      */
  61.     private $editedBy;
  63.     /**
  64.      * @ORM\ManyToOne(targetEntity=Student::class)
  65.      * @ORM\JoinColumn(nullable=true)
  66.      */
  67.     private $student;
  69.     /**
  70.      * @ORM\ManyToOne(targetEntity=Person::class)
  71.      * @ORM\JoinColumn(nullable=true)
  72.      */
  73.     private $person;
  75.     /**
  76.      * @ORM\ManyToOne(targetEntity=UserSettings::class)
  77.      * @ORM\JoinColumn(nullable=true)
  78.      */
  79.     private $userSettings;
  81.     /**
  82.      * @ORM\ManyToOne(targetEntity=Candidate::class)
  83.      * @ORM\JoinColumn(nullable=true)
  84.      */
  85.     private $candidate;
  87.     /**
  88.      * @ORM\ManyToOne(targetEntity=Payment::class)
  89.      * @ORM\JoinColumn(nullable=true)
  90.      */
  91.     private $payment;
  93.     /**
  94.      * @ORM\Column(type="text", nullable=true)
  95.      */
  96.     private $data;
  98.     /**
  99.      * @ORM\Column(type="text", nullable=true)
  100.      */
  101.     private $oldData;
  103.     /**
  104.      * @ORM\Column(type="string", length=255, nullable=true)
  105.      */
  106.     private $entityText;
  108.     /**
  109.      * @ORM\Column(type="text", nullable=true)
  110.      */
  111.     private $fields;
  113.     /**
  114.      * @ORM\Column(type="datetime", nullable=true)
  115.      */
  116.     private $updatedAt;
  118.     /**
  119.      * Has higher priority than editedBy.
  120.      * @ORM\Column(type="string", length=255, nullable=true)
  121.      */
  122.     private $editedByText;
  124.     public function __construct()
  125.     {
  126.         $this->createdAt = new \DateTime();
  127.         $this->updatedAt = new \DateTime();
  128.     }
  130.     public function getId(): ?int
  131.     {
  132.         return $this->id;
  133.     }
  135.     public function getEntityClass($full = false): ?string
  136.     {
  137.         return ($full ? "App\\Entity\\" : "") . $this->entityClass;
  138.     }
  140.     public function getEntityServiceClass(): ?string
  141.     {
  142.         $result = "App\\Service\\" . $this->getEntityClass() . "Service";
  143.         if (!class_exists($result)) {
  144.             $result = "App\\Service\\" . $this->getEntityClass()
  145.                 . "\\" . $this->getEntityClass() . "Service";
  146.             if (!class_exists($result)) {
  147.                 $result = null;
  148.             }
  149.         }
  150.         return $result;
  151.     }
  153.     public function setEntityClass(string $entityClass): self
  154.     {
  155.         $this->entityClass = $entityClass;
  156.         return $this;
  157.     }
  159.     public function getType(): ?string
  160.     {
  161.         return $this->type;
  162.     }
  164.     public function isCreateType(): bool
  165.     {
  166.         return $this->type === Type::TYPE_CREATE;
  167.     }
  169.     public function isUpdateType(): bool
  170.     {
  171.         return $this->type === Type::TYPE_UPDATE;
  172.     }
  174.     public function isDeleteType(): bool
  175.     {
  176.         return $this->type === Type::TYPE_DELETE;
  177.     }
  179.     public function isRecoverType(): bool
  180.     {
  181.         return $this->type === Type::TYPE_RECOVER;
  182.     }
  184.     public function setType(string $type): self
  185.     {
  186.         $this->type = $type;
  187.         return $this;
  188.     }
  190.     public function getCreatedAt(): ?\DateTime
  191.     {
  192.         return $this->createdAt;
  193.     }
  195.     public function setCreatedAt(\DateTime $createdAt): self
  196.     {
  197.         $this->createdAt = $createdAt;
  198.         return $this;
  199.     }
  201.     public function getFieldName(): ?string
  202.     {
  203.         return $this->fieldName;
  204.     }
  206.     public function setFieldName(?string $fieldName): self
  207.     {
  208.         $this->fieldName = $fieldName;
  209.         return $this;
  210.     }
  212.     public function getOldValue(): ?string
  213.     {
  214.         return $this->oldValue;
  215.     }
  217.     public function setOldValue(?string $oldValue): self
  218.     {
  219.         $this->oldValue = $oldValue;
  220.         return $this;
  221.     }
  223.     public function getNewValue(): ?string
  224.     {
  225.         return $this->newValue;
  226.     }
  228.     public function setNewValue(?string $newValue): self
  229.     {
  230.         $this->newValue = $newValue;
  231.         return $this;
  232.     }
  234.     public function getEntityId(): ?int
  235.     {
  236.         return $this->entityId;
  237.     }
  239.     public function setEntityId(?int $entityId): self
  240.     {
  241.         $this->entityId = $entityId;
  242.         return $this;
  243.     }
  245.     private function getEditedBy($ignorePriority = false): ?User
  246.     {
  247.         if ($this->editedByText && !$ignorePriority) {
  248.             throw new \Exception('editedByText has higher priority');
  249.         }
  250.         return $this->editedBy;
  251.     }
  253.     public function setEditedBy(?User $editedBy): self
  254.     {
  255.         $this->editedBy = $editedBy;
  256.         return $this;
  257.     }
  259. //    public function getStudent(): ?Student
  260. //    {
  261. //        return $this->student;
  262. //    }
  263. //
  264. //    public function setStudent(?Student $student): self
  265. //    {
  266. //        $this->student = $student;
  267. //        return $this;
  268. //    }
  270. //    public function getPerson(): ?Person
  271. //    {
  272. //        return $this->person;
  273. //    }
  274. //
  275. //    public function setPerson(?Person $person): self
  276. //    {
  277. //        $this->person = $person;
  278. //        return $this;
  279. //    }
  281. //    public function getUserSettings(): ?UserSettings
  282. //    {
  283. //        return $this->userSettings;
  284. //    }
  285. //
  286. //    public function setUserSettings(?UserSettings $userSettings): self
  287. //    {
  288. //        $this->userSettings = $userSettings;
  289. //        return $this;
  290. //    }
  292. //    public function getCandidate(): ?Candidate
  293. //    {
  294. //        return $this->candidate;
  295. //    }
  297. //    public function setCandidate(?Candidate $candidate): self
  298. //    {
  299. //        $this->candidate = $candidate;
  300. //        return $this;
  301. //    }
  303. //    public function getPayment(): ?Payment
  304. //    {
  305. //        return $this->payment;
  306. //    }
  307. //
  308. //    public function setPayment(?Payment $payment): self
  309. //    {
  310. //        $this->payment = $payment;
  311. //        return $this;
  312. //    }
  314.     public function getTypeText(): string
  315.     {
  316.         return Type::getText($this->type);
  317.     }
  319.     public function getTypeCss(): string
  320.     {
  321.         return Type::getCssClass($this->type);
  322.     }
  324.     public function getEntityClassCss(): string
  325.     {
  326.         return EntityService::getEntityClassCssClass("App\\Entity\\{$this->entityClass}");
  327.     }
  329.     public function getEntityClassText(): string
  330.     {
  331.         return EntityService::getEntityClassText($this->entityClass);
  332.     }
  334. //    public function getEntity()
  335. //    {
  336. //        return $this->getPerson() ?? $this->getStudent() ?? $this->getUserSettings() ?? $this->getCandidate() ?? $this->getPayment();
  337. //    }
  339. //    public function setEntity($entity): self
  340. //    {
  341. //        if ($entity instanceof Person) {
  342. //            return $this->setPerson($entity);
  343. //        } elseif ($entity instanceof Student) {
  344. //            return $this->setStudent($entity);
  345. //        } elseif ($entity instanceof UserSettings) {
  346. //            return $this->setUserSettings($entity);
  347. //        } elseif ($entity instanceof Candidate) {
  348. //            return $this->setCandidate($entity);
  349. //        } elseif ($entity instanceof Payment) {
  350. //            return $this->setPayment($entity);
  351. //        }
  352. //        return $this;
  353. //    }
  355. //    public function getEntityFieldText(): ?string
  356. //    {
  357. //        $entityClass = "App\\Entity\\{$this->entityClass}";
  358. //        $text = null;
  359. //        $entity = $this->getEntity();
  360. //        if ($entity && method_exists($entityClass, 'getFieldText')) {
  361. //            $text = $entityClass::getFieldText($this->fieldName);
  362. //        }
  363. //        return $text ?: $this->fieldName;
  364. //    }
  366. //    public function getOldFieldValueText(): ?string
  367. //    {
  368. //        $oldValue = $this->getOldValue();
  369. //        return $this->getFieldValueText($oldValue);
  370. //    }
  372. //    public function getNewFieldValueText(): ?string
  373. //    {
  374. //        $newValue = $this->getNewValue();
  375. //        $result = $this->getFieldValueText($newValue);
  376. //        return $result;
  377. //    }
  379. //    private function getFieldValueText($val)
  380. //    {
  381. //        return EntityLogService::entityFieldValueText(
  382. //            $this->getEntity(), $this->fieldName, $val
  383. //        );
  384. //    }
  386.     public function getData(): ?array
  387.     {
  388.         return json_decode($this->data, true);
  389.     }
  391.     public function setData(?array $data): self
  392.     {
  393.         $this->data = json_encode($data,
  394.             JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
  396.         return $this;
  397.     }
  399.     public function addData(array $data, $addOnlyNew = false): self
  400.     {
  401.         $currentData = $this->getData() ?: [];
  402.         if ($addOnlyNew) {
  403.            foreach ($data as $key => $value) {
  404.                if (!array_key_exists($key, $currentData)) {
  405.                    $currentData[$key] = $value;
  406.                }
  407.            }
  408.         } else {
  409.             $data = $this->getDataWithKeyPostfix($data, count($currentData));
  410.             $newData = array_merge($currentData, $data);
  411.         }
  412.         return $this->setData($newData);
  413.     }
  415.     private function getDataWithKeyPostfix(array $data, int $currentDataCount): array
  416.     {
  417.         $dataWithKeyPostfix = [];
  418.         $postfix = $currentDataCount;
  419.         foreach ($data as $key => $value) {
  420.             $dataWithKeyPostfix["{$key}_$postfix"] = $value;
  421.         }
  422.         return $dataWithKeyPostfix;
  423.     }
  425.     public function getOldData(): ?array
  426.     {
  427.         return json_decode($this->oldData, true);
  428.     }
  430.     public function setOldData(?array $oldData): self
  431.     {
  432.         $this->oldData = json_encode($oldData,
  433.             JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
  435.         return $this;
  436.     }
  438.     public function addOldData(array $oldData, $addOnlyNew = false): self
  439.     {
  440.         $currentOldData = $this->getOldData() ?: [];
  441.         if ($addOnlyNew) {
  442.             foreach ($oldData as $key => $value) {
  443.                 if (!array_key_exists($key, $currentOldData)) {
  444.                     $currentOldData[$key] = $value;
  445.                 }
  446.             }
  447.                 return $this->setOldData($currentOldData);
  448.         } else {
  449.             $oldData = $this->getDataWithKeyPostfix($oldData, count($currentOldData));
  450.             $newOldData = array_merge($currentOldData, $oldData);
  451.             return $this->setOldData($newOldData);
  452.         }
  453.     }
  455.     public function setEntityText(?string $entityText): self
  456.     {
  457.         $this->entityText = $entityText;
  459.         return $this;
  460.     }
  462.     public function getEntityText(): ?string
  463.     {
  464.         return $this->entityText;
  465.     }
  467.     public function getFields(): ?string
  468.     {
  469.         return $this->fields;
  470.     }
  472.     public function setFields(?string $fields): self
  473.     {
  474.         $this->fields = $fields;
  476.         return $this;
  477.     }
  479.     public function addFieldsIfNotExists(array $fields): self
  480.     {
  481.         $currentFields = $this->getFields() ? explode(",", $this->getFields()) : [];
  482.         $newFields = array_unique(array_merge($currentFields, $fields));
  483.         return $this->setFields(implode(",", $newFields));
  484.     }
  486.     public function getUpdatedAt($real = false): ?\DateTimeInterface
  487.     {
  488.         if (!$real && !$this->updatedAt) {
  489.             return $this->createdAt;
  490.         }
  491.         return $this->updatedAt;
  492.     }
  494.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  495.     {
  496.         $this->updatedAt = $updatedAt;
  498.         return $this;
  499.     }
  501.     public function setDataByKey(string $key, $value): self
  502.     {
  503.         $data = $this->getData() ?: [];
  504.         $data[$key] = $value;
  505.         return $this->setData($data);
  506.     }
  508.     public function setOldDataByKey(string $key, $value): self
  509.     {
  510.         $oldData = $this->getOldData() ?: [];
  511.         $oldData[$key] = $value;
  512.         return $this->setOldData($oldData);
  513.     }
  515.     public function updateData(array $data): self
  516.     {
  517.         foreach ($data as $key => $value) {
  518.             $this->setDataByKey($key, $value);
  519.         }
  520.         return $this;
  521.     }
  523.     public function updateOldData(array $oldData): self
  524.     {
  525.         foreach ($oldData as $key => $value) {
  526.             $this->setOldDataByKey($key, $value);
  527.         }
  528.         return $this;
  529.     }
  531.     public function getEditedByText(): ?string
  532.     {
  533.         return $this->editedByText
  534.             ?: ($this->getEditedBy(true) ? $this->getEditedBy(true)->getName() : null);
  535.     }
  537.     public function setEditedByText(?string $editedByText): self
  538.     {
  539.         $this->editedByText = $editedByText;
  541.         return $this;
  542.     }
  543. }