src/Entity/EntityLog.php line 15

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Enum\EntityLog\Type;
  6. use App\Library\Utils\Dev\ReflectionUtils\ReflectionUtils;
  7. use App\Repository\EntityLogRepository;
  8. use App\Service\EntityLog\EntityLogService;
  9. use App\Service\EntityService;
  10. use Doctrine\ORM\Mapping as ORM;
  12. /**
  13.  * @ORM\Entity(repositoryClass=EntityLogRepository::class)
  14.  */
  15. class EntityLog
  16. {
  17.     /**
  18.      * @ORM\Id
  19.      * @ORM\GeneratedValue
  20.      * @ORM\Column(type="integer")
  21.      */
  22.     private $id;
  24.     /**
  25.      * @ORM\Column(type="string", length=255)
  26.      */
  27.     private $entityClass;
  29.     /**
  30.      * @ORM\Column(type="enum", options={"values"="entity_log_enum", "default"="update"})
  31.      */
  32.     private $type = Type::TYPE_UPDATE;
  34.     /**
  35.      * @ORM\Column(type="datetime")
  36.      */
  37.     private $createdAt;
  39.     /**
  40.      * @ORM\Column(type="string", length=255, nullable=true)
  41.      */
  42.     private $fieldName;
  44.     /**
  45.      * @ORM\Column(type="text", nullable=true)
  46.      */
  47.     private $oldValue;
  49.     /**
  50.      * @ORM\Column(type="text", nullable=true)
  51.      */
  52.     private $newValue;
  54.     /**
  55.      * @ORM\Column(type="integer", nullable=true)
  56.      */
  57.     private $entityId;
  59.     /**
  60.      * @ORM\ManyToOne(targetEntity=User::class)
  61.      * @ORM\JoinColumn(nullable=true)
  62.      */
  63.     private $editedBy;
  65.     /**
  66.      * @ORM\ManyToOne(targetEntity=Student::class)
  67.      * @ORM\JoinColumn(nullable=true)
  68.      */
  69.     private $student;
  71.     /**
  72.      * @ORM\ManyToOne(targetEntity=Person::class)
  73.      * @ORM\JoinColumn(nullable=true)
  74.      */
  75.     private $person;
  77.     /**
  78.      * @ORM\ManyToOne(targetEntity=UserSettings::class)
  79.      * @ORM\JoinColumn(nullable=true)
  80.      */
  81.     private $userSettings;
  83.     /**
  84.      * @ORM\ManyToOne(targetEntity=Candidate::class)
  85.      * @ORM\JoinColumn(nullable=true)
  86.      */
  87.     private $candidate;
  89.     /**
  90.      * @ORM\ManyToOne(targetEntity=Payment::class)
  91.      * @ORM\JoinColumn(nullable=true)
  92.      */
  93.     private $payment;
  95.     /**
  96.      * @ORM\Column(type="text", nullable=true)
  97.      */
  98.     private $data;
  100.     /**
  101.      * @ORM\Column(type="text", nullable=true)
  102.      */
  103.     private $oldData;
  105.     /**
  106.      * @ORM\Column(type="string", length=255, nullable=true)
  107.      */
  108.     private $entityText;
  110.     /**
  111.      * @ORM\Column(type="text", nullable=true)
  112.      */
  113.     private $fields;
  115.     /**
  116.      * @ORM\Column(type="datetime", nullable=true)
  117.      */
  118.     private $updatedAt;
  120.     public function __construct()
  121.     {
  122.         $this->createdAt = new \DateTime();
  123.         $this->updatedAt = new \DateTime();
  124.     }
  126.     public function getId(): ?int
  127.     {
  128.         return $this->id;
  129.     }
  131.     public function getEntityClass($full = false): ?string
  132.     {
  133.         return ($full ? "App\\Entity\\" : "") . $this->entityClass;
  134.     }
  136.     public function getEntityServiceClass(): ?string
  137.     {
  138.         $result = "App\\Service\\" . $this->getEntityClass() . "Service";
  139.         if (!class_exists($result)) {
  140.             $result = "App\\Service\\" . $this->getEntityClass()
  141.                 . "\\" . $this->getEntityClass() . "Service";
  142.             if (!class_exists($result)) {
  143.                 $result = null;
  144.             }
  145.         }
  146.         return $result;
  147.     }
  149.     public function setEntityClass(string $entityClass): self
  150.     {
  151.         $this->entityClass = $entityClass;
  152.         return $this;
  153.     }
  155.     public function getType(): ?string
  156.     {
  157.         return $this->type;
  158.     }
  160.     public function isCreateType(): bool
  161.     {
  162.         return $this->type === Type::TYPE_CREATE;
  163.     }
  165.     public function isUpdateType(): bool
  166.     {
  167.         return $this->type === Type::TYPE_UPDATE;
  168.     }
  170.     public function isDeleteType(): bool
  171.     {
  172.         return $this->type === Type::TYPE_DELETE;
  173.     }
  175.     public function isRecoverType(): bool
  176.     {
  177.         return $this->type === Type::TYPE_RECOVER;
  178.     }
  180.     public function setType(string $type): self
  181.     {
  182.         $this->type = $type;
  183.         return $this;
  184.     }
  186.     public function getCreatedAt(): ?\DateTime
  187.     {
  188.         return $this->createdAt;
  189.     }
  191.     public function setCreatedAt(\DateTime $createdAt): self
  192.     {
  193.         $this->createdAt = $createdAt;
  194.         return $this;
  195.     }
  197.     public function getFieldName(): ?string
  198.     {
  199.         return $this->fieldName;
  200.     }
  202.     public function setFieldName(?string $fieldName): self
  203.     {
  204.         $this->fieldName = $fieldName;
  205.         return $this;
  206.     }
  208.     public function getOldValue(): ?string
  209.     {
  210.         return $this->oldValue;
  211.     }
  213.     public function setOldValue(?string $oldValue): self
  214.     {
  215.         $this->oldValue = $oldValue;
  216.         return $this;
  217.     }
  219.     public function getNewValue(): ?string
  220.     {
  221.         return $this->newValue;
  222.     }
  224.     public function setNewValue(?string $newValue): self
  225.     {
  226.         $this->newValue = $newValue;
  227.         return $this;
  228.     }
  230.     public function getEntityId(): ?int
  231.     {
  232.         return $this->entityId;
  233.     }
  235.     public function setEntityId(?int $entityId): self
  236.     {
  237.         $this->entityId = $entityId;
  238.         return $this;
  239.     }
  241.     public function getEditedBy(): ?User
  242.     {
  243.         return $this->editedBy;
  244.     }
  246.     public function setEditedBy(?User $editedBy): self
  247.     {
  248.         $this->editedBy = $editedBy;
  249.         return $this;
  250.     }
  252.     public function getStudent(): ?Student
  253.     {
  254.         return $this->student;
  255.     }
  257.     public function setStudent(?Student $student): self
  258.     {
  259.         $this->student = $student;
  260.         return $this;
  261.     }
  263.     public function getPerson(): ?Person
  264.     {
  265.         return $this->person;
  266.     }
  268.     public function setPerson(?Person $person): self
  269.     {
  270.         $this->person = $person;
  271.         return $this;
  272.     }
  274.     public function getUserSettings(): ?UserSettings
  275.     {
  276.         return $this->userSettings;
  277.     }
  279.     public function setUserSettings(?UserSettings $userSettings): self
  280.     {
  281.         $this->userSettings = $userSettings;
  282.         return $this;
  283.     }
  285.     public function getCandidate(): ?Candidate
  286.     {
  287.         return $this->candidate;
  288.     }
  290.     public function setCandidate(?Candidate $candidate): self
  291.     {
  292.         $this->candidate = $candidate;
  293.         return $this;
  294.     }
  296.     public function getPayment(): ?Payment
  297.     {
  298.         return $this->payment;
  299.     }
  301.     public function setPayment(?Payment $payment): self
  302.     {
  303.         $this->payment = $payment;
  304.         return $this;
  305.     }
  307.     public function getTypeText(): string
  308.     {
  309.         return Type::getText($this->type);
  310.     }
  312.     public function getTypeCss(): string
  313.     {
  314.         return Type::getCssClass($this->type);
  315.     }
  317.     public function getEntityClassCss(): string
  318.     {
  319.         return EntityService::getEntityClassCssClass("App\\Entity\\{$this->entityClass}");
  320.     }
  322.     public function getEntityClassText(): string
  323.     {
  324.         return EntityService::getEntityClassText($this->entityClass);
  325.     }
  327.     public function getEntity()
  328.     {
  329.         return $this->getPerson() ?? $this->getStudent() ?? $this->getUserSettings() ?? $this->getCandidate() ?? $this->getPayment();
  330.     }
  332.     public function setEntity($entity): self
  333.     {
  334.         if ($entity instanceof Person) {
  335.             return $this->setPerson($entity);
  336.         } elseif ($entity instanceof Student) {
  337.             return $this->setStudent($entity);
  338.         } elseif ($entity instanceof UserSettings) {
  339.             return $this->setUserSettings($entity);
  340.         } elseif ($entity instanceof Candidate) {
  341.             return $this->setCandidate($entity);
  342.         } elseif ($entity instanceof Payment) {
  343.             return $this->setPayment($entity);
  344.         }
  345.         return $this;
  346.     }
  348.     public function getEntityFieldText(): ?string
  349.     {
  350.         $entityClass = "App\\Entity\\{$this->entityClass}";
  351.         $text = null;
  352.         $entity = $this->getEntity();
  353.         if ($entity && method_exists($entityClass, 'getFieldText')) {
  354.             $text = $entityClass::getFieldText($this->fieldName);
  355.         }
  356.         return $text ?: $this->fieldName;
  357.     }
  359.     public function getOldFieldValueText(): ?string
  360.     {
  361.         $oldValue = $this->getOldValue();
  362.         return $this->getFieldValueText($oldValue);
  363.     }
  365.     public function getNewFieldValueText(): ?string
  366.     {
  367.         $newValue = $this->getNewValue();
  368.         $result = $this->getFieldValueText($newValue);
  369.         return $result;
  370.     }
  372.     private function getFieldValueText($val)
  373.     {
  374.         return EntityLogService::entityFieldValueText(
  375.             $this->getEntity(), $this->fieldName, $val
  376.         );
  377.     }
  379.     public function getData(): ?array
  380.     {
  381.         return json_decode($this->data, true);
  382.     }
  384.     public function setData(?array $data): self
  385.     {
  386.         $this->data = json_encode($data,
  387.             JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
  389.         return $this;
  390.     }
  392.     public function addData(array $data, $addOnlyNew = false): self
  393.     {
  394.         $currentData = $this->getData() ?: [];
  395.         if ($addOnlyNew) {
  396.            foreach ($data as $key => $value) {
  397.                if (!array_key_exists($key, $currentData)) {
  398.                    $currentData[$key] = $value;
  399.                }
  400.            }
  401.         } else {
  402.             $data = $this->getDataWithKeyPostfix($data, count($currentData));
  403.             $newData = array_merge($currentData, $data);
  404.         }
  405.         return $this->setData($newData);
  406.     }
  408.     private function getDataWithKeyPostfix(array $data, int $currentDataCount): array
  409.     {
  410.         $dataWithKeyPostfix = [];
  411.         $postfix = $currentDataCount;
  412.         foreach ($data as $key => $value) {
  413.             $dataWithKeyPostfix["{$key}_$postfix"] = $value;
  414.         }
  415.         return $dataWithKeyPostfix;
  416.     }
  418.     public function getOldData(): ?array
  419.     {
  420.         return json_decode($this->oldData, true);
  421.     }
  423.     public function setOldData(?array $oldData): self
  424.     {
  425.         $this->oldData = json_encode($oldData,
  426.             JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
  428.         return $this;
  429.     }
  431.     public function addOldData(array $oldData, $addOnlyNew = false): self
  432.     {
  433.         $currentOldData = $this->getOldData() ?: [];
  434.         if ($addOnlyNew) {
  435.             foreach ($oldData as $key => $value) {
  436.                 if (!array_key_exists($key, $currentOldData)) {
  437.                     $currentOldData[$key] = $value;
  438.                 }
  439.             }
  440.                 return $this->setOldData($currentOldData);
  441.         } else {
  442.             $oldData = $this->getDataWithKeyPostfix($oldData, count($currentOldData));
  443.             $newOldData = array_merge($currentOldData, $oldData);
  444.             return $this->setOldData($newOldData);
  445.         }
  446.     }
  448.     public function setEntityText(?string $entityText): self
  449.     {
  450.         $this->entityText = $entityText;
  452.         return $this;
  453.     }
  455.     public function getEntityText(): ?string
  456.     {
  457.         return $this->entityText;
  458.     }
  460.     public function getFields(): ?string
  461.     {
  462.         return $this->fields;
  463.     }
  465.     public function setFields(?string $fields): self
  466.     {
  467.         $this->fields = $fields;
  469.         return $this;
  470.     }
  472.     public function addFieldsIfNotExists(array $fields): self
  473.     {
  474.         $currentFields = $this->getFields() ? explode(",", $this->getFields()) : [];
  475.         $newFields = array_unique(array_merge($currentFields, $fields));
  476.         return $this->setFields(implode(",", $newFields));
  477.     }
  479.     public function getUpdatedAt($real = false): ?\DateTimeInterface
  480.     {
  481.         if (!$real && !$this->updatedAt) {
  482.             return $this->createdAt;
  483.         }
  484.         return $this->updatedAt;
  485.     }
  487.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  488.     {
  489.         $this->updatedAt = $updatedAt;
  491.         return $this;
  492.     }
  494.     public function setDataByKey(string $key, $value): self
  495.     {
  496.         $data = $this->getData() ?: [];
  497.         $data[$key] = $value;
  498.         return $this->setData($data);
  499.     }
  501.     public function setOldDataByKey(string $key, $value): self
  502.     {
  503.         $oldData = $this->getOldData() ?: [];
  504.         $oldData[$key] = $value;
  505.         return $this->setOldData($oldData);
  506.     }
  508.     public function updateData(array $data): self
  509.     {
  510.         foreach ($data as $key => $value) {
  511.             $this->setDataByKey($key, $value);
  512.         }
  513.         return $this;
  514.     }
  516.     public function updateOldData(array $oldData): self
  517.     {
  518.         foreach ($oldData as $key => $value) {
  519.             $this->setOldDataByKey($key, $value);
  520.         }
  521.         return $this;
  522.     }
  523. }