src/Entity/Registration.php line 19

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Enum\RegistrationOrigin;
  6. use App\Entity\Enum\RegistrationStatus;
  7. use App\Entity\Enum\TransactionStatus;
  8. use App\Entity\Traits\Identifiable;
  9. use App\Entity\Traits\Timestampable;
  10. use App\Repository\RegistrationRepository;
  11. use DateInterval;
  12. use DateTimeImmutable;
  13. use Doctrine\Common\Collections\ArrayCollection;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\DBAL\Types\Types;
  16. use Doctrine\ORM\Mapping as ORM;
  18. #[ORM\Entity(repositoryClass: RegistrationRepository::class)]
  19. class Registration
  20. {
  21.     use Timestampable;
  22.     use Identifiable;
  24.     #[ORM\Column(type: 'string', length: 20, enumType: RegistrationStatus::class)]
  25.     private RegistrationStatus $status = RegistrationStatus::Prospect;
  27.     #[ORM\Column(type: 'boolean', nullable: true)]
  28.     private $hasTaxReceipt;
  30.     #[ORM\Column(type: 'boolean', nullable: true)]
  31.     private $hasCompanyReceipt;
  33.     #[ORM\ManyToOne(targetEntity: Person::class, inversedBy: 'registrations', cascade: ['persist'])]
  34.     #[ORM\JoinColumn(nullable: false)]
  35.     private $person;
  37.     #[ORM\ManyToOne(targetEntity: Person::class, inversedBy: 'signedRegistrations')]
  38.     private $signatory;
  40.     #[ORM\ManyToMany(targetEntity: Slot::class, inversedBy: 'registrations')]
  41.     private $slots;
  43.     #[ORM\ManyToOne(targetEntity: Lesson::class, inversedBy: 'registrations')]
  44.     private $lesson;
  46.     #[ORM\ManyToOne(targetEntity: Season::class, inversedBy: 'registrations')]
  47.     #[ORM\JoinColumn(nullable: false)]
  48.     private $season;
  50.     #[ORM\OneToOne(mappedBy: 'registration', targetEntity: Order::class, cascade: ['persist', 'remove'])]
  51.     private $order;
  53.     #[ORM\ManyToMany(targetEntity: Lesson::class)]
  54.     #[ORM\JoinTable(name: 'registration_proposed_lesson')]
  55.     private $proposedLessons;
  57.     #[ORM\ManyToMany(targetEntity: Slot::class, inversedBy: 'registrationPropositions')]
  58.     #[ORM\JoinTable(name: 'registration_proposed_slot')]
  59.     private $proposedSlots;
  61.     #[ORM\Column(type: 'smallint', nullable: true)]
  62.     private $validationStep = 1;
  64.     #[ORM\Column(type: 'integer', nullable: true)]
  65.     private $oldId;
  67.     #[ORM\OneToMany(mappedBy: 'registration', targetEntity: Document::class, cascade: ['remove'])]
  68.     private $documents;
  70.     #[ORM\Column(type: 'smallint')]
  71.     private $reminder = 0;
  73.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  74.     private ?\DateTimeInterface $lastReminder = null;
  76.     #[ORM\Column(type: 'string', length: 100, enumType: RegistrationOrigin::class)]
  77.     private $origin = RegistrationOrigin::Frontoffice;
  79.     public function __construct()
  80.     {
  81.         $this->slots = new ArrayCollection();
  82.         $this->proposedLessons = new ArrayCollection();
  83.         $this->proposedSlots = new ArrayCollection();
  84.         $this->setOrder(new Order());
  85.         $this->documents = new ArrayCollection();
  86.     }
  88.     public function getStatus(): ?RegistrationStatus
  89.     {
  90.         return $this->status;
  91.     }
  93.     public function setStatus(RegistrationStatus $status): self
  94.     {
  95.         $this->status = $status;
  97.         return $this;
  98.     }
  100.     public function getSignatory(): ?Person
  101.     {
  102.         return $this->signatory;
  103.     }
  105.     public function setSignatory(?Person $signatory): self
  106.     {
  107.         $this->signatory = $signatory;
  109.         return $this;
  110.     }
  112.     public function getHasTaxReceipt(): ?bool
  113.     {
  114.         return $this->hasTaxReceipt;
  115.     }
  117.     public function setHasTaxReceipt(bool $hasTaxReceipt): self
  118.     {
  119.         $this->hasTaxReceipt = $hasTaxReceipt;
  121.         return $this;
  122.     }
  124.     public function getHasCompanyReceipt(): ?bool
  125.     {
  126.         return $this->hasCompanyReceipt;
  127.     }
  129.     public function setHasCompanyReceipt(bool $hasCompanyReceipt): self
  130.     {
  131.         $this->hasCompanyReceipt = $hasCompanyReceipt;
  133.         return $this;
  134.     }
  136.     /**
  137.      * @return Collection<int, Slot>
  138.      */
  139.     public function getSlots(): Collection
  140.     {
  141.         return $this->slots;
  142.     }
  144.     public function addSlot(Slot $slot): self
  145.     {
  146.         if (!$this->slots->contains($slot)) {
  147.             $this->slots[] = $slot;
  148.             $slot->addRegistration($this);
  149.         }
  151.         return $this;
  152.     }
  154.     public function removeSlot(Slot $slot): self
  155.     {
  156.         if ($this->slots->removeElement($slot)) {
  157.             $slot->removeRegistration($this);
  158.         }
  160.         return $this;
  161.     }
  163.     public function getPerson(): ?Person
  164.     {
  165.         return $this->person;
  166.     }
  168.     public function setPerson(?Person $person): self
  169.     {
  170.         $this->person = $person;
  172.         return $this;
  173.     }
  175.     public function getSeason(): ?Season
  176.     {
  177.         return $this->season;
  178.     }
  180.     public function setSeason(?Season $season): self
  181.     {
  182.         $this->season = $season;
  184.         return $this;
  185.     }
  187.     public function getOrder(): ?Order
  188.     {
  189.         return $this->order;
  190.     }
  192.     public function setOrder(?Order $order): self
  193.     {
  194.         // unset the owning side of the relation if necessary
  195.         if ($order === null && $this->order !== null) {
  196.             $this->order->setRegistration(null);
  197.         }
  199.         // set the owning side of the relation if necessary
  200.         if ($order !== null && $order->getRegistration() !== $this) {
  201.             $order->setRegistration($this);
  202.         }
  204.         $this->order = $order;
  206.         return $this;
  207.     }
  209.     /**
  210.      * @return Collection<int, Lesson>
  211.      */
  212.     public function getProposedLessons(): Collection
  213.     {
  214.         return $this->proposedLessons;
  215.     }
  217.     public function addProposedLesson(Lesson $proposedLesson): self
  218.     {
  219.         if (!$this->proposedLessons->contains($proposedLesson)) {
  220.             $this->proposedLessons[] = $proposedLesson;
  221.         }
  223.         return $this;
  224.     }
  226.     public function removeProposedLesson(Lesson $proposedLesson): self
  227.     {
  228.         $this->proposedLessons->removeElement($proposedLesson);
  230.         return $this;
  231.     }
  233.     /**
  234.      * @return Collection<int, Slot>
  235.      */
  236.     public function getProposedSlots(): Collection
  237.     {
  238.         return $this->proposedSlots;
  239.     }
  241.     public function addProposedSlot(Slot $proposedSlot): self
  242.     {
  243.         if (!$this->proposedSlots->contains($proposedSlot)) {
  244.             $this->proposedSlots[] = $proposedSlot;
  245.         }
  247.         return $this;
  248.     }
  250.     public function removeProposedSlot(Slot $proposedSlot): self
  251.     {
  252.         $this->proposedSlots->removeElement($proposedSlot);
  254.         return $this;
  255.     }
  257.     public function getLesson(): ?Lesson
  258.     {
  259.         return $this->lesson;
  260.     }
  262.     public function setLesson(?Lesson $lesson): self
  263.     {
  264.         $this->lesson = $lesson;
  266.         return $this;
  267.     }
  269.     public function getValidationStep(): ?int
  270.     {
  271.         return $this->validationStep;
  272.     }
  274.     public function setValidationStep(?int $validationStep): self
  275.     {
  276.         $this->validationStep = $validationStep;
  278.         return $this;
  279.     }
  281.     public static function unaffectLessonsAndSlots(self $registration): self
  282.     {
  283.         $registration->setLesson(null);
  284.         $registration->getSlots()->clear();
  286.         return $registration;
  287.     }
  289.     public function getSection(): ?Section
  290.     {
  291.         return $this->getSeason()?->getSection();
  292.     }
  294.     public function getOldId(): ?int
  295.     {
  296.         return $this->oldId;
  297.     }
  299.     public function setOldId(?int $oldId): self
  300.     {
  301.         $this->oldId = $oldId;
  303.         return $this;
  304.     }
  306.     /**
  307.      * @return Collection<int, Document>
  308.      */
  309.     public function getDocuments(bool $activeVersionOnly = false): Collection
  310.     {
  311.         $documents = $this->documents;
  312.         if ($activeVersionOnly) {
  313.             $finalArray = [];
  314.             $models = [];
  315.             $documentsArray = array_reverse($documents->toArray());
  316.             /** @var Document $item */
  317.             foreach ($documentsArray as $item) {
  318.                 $modelId = $item->getModel()?->getId();
  319.                 if ($modelId) {
  320.                     if (!in_array($modelId, $models, true)) {
  321.                         $models[] = $modelId;
  322.                         $finalArray[] = $item;
  323.                     }
  325.                 } else {
  326.                     $finalArray[] = $item;
  327.                 }
  328.             }
  330.             return new ArrayCollection(array_reverse($finalArray));
  331.         }
  333.         return $documents;
  334.     }
  336.     public function addDocument(Document $document): self
  337.     {
  338.         if (!$this->documents->contains($document)) {
  339.             $this->documents[] = $document;
  340.             $document->setRegistration($this);
  341.         }
  343.         return $this;
  344.     }
  346.     public function removeDocument(Document $document): self
  347.     {
  348.         if ($this->documents->removeElement($document)) {
  349.             // set the owning side to null (unless already changed)
  350.             if ($document->getRegistration() === $this) {
  351.                 $document->setRegistration(null);
  352.             }
  353.         }
  355.         return $this;
  356.     }
  358.     /**
  359.      * @param bool $includeRentals
  360.      * @param bool $linkDocuments
  361.      * @return Collection<int, DocumentModel>
  362.      */
  363.     public function getRemainingDocumentModels(bool $includeRentals = true, bool $linkDocuments = false, bool $removeAdminOnly = false): Collection
  364.     {
  365.         /** @var Collection<int, DocumentModel> $models */
  366.         $models = new ArrayCollection();
  367.         $cart = $this->getOrder()?->getCart();
  368.         foreach ($cart->getDiscounts() as $itemDiscount) {
  369.             foreach ($itemDiscount->getDiscount()?->getModel()?->getDocumentModels() ?? [] as $model) {
  370.                 if ($model->getSeason()->getGlobalSeason()->getId() ===
  371.                     $this->getSeason()->getGlobalSeason()->getId()) {
  372.                     $models->add($model);
  373.                 }
  374.             }
  375.         }
  376.         foreach ($this->getSeason()?->getDocumentModels(false) ?? [] as $model) {
  377.             if (($this->getPerson()->isMinor() && $model->getIsForMinor()) ||
  378.                 (!$this->getPerson()->isMinor() && $model->getIsForAdult())) {
  379.                 $models->add($model);
  380.             }
  381.         }
  383.         // Remove all models that are for admins only
  384.         if ($removeAdminOnly) {
  385.             foreach ($models as $model) {
  386.                 if ($model->isAdminOnly()) {
  387.                     $models->removeElement($model);
  388.                 }
  389.             }
  390.         }
  392.         if ($linkDocuments) {
  393.             foreach ($models as $model) {
  394.                 foreach ($this->getDocuments() as $document) {
  395.                     if ($document->getModel() === $model) {
  396.                         $model->addLinkedDocument($document);
  397.                     }
  398.                 }
  399.             }
  400.         }
  402.         return $models;
  403.     }
  405.     public function getReminder(): ?int
  406.     {
  407.         return $this->reminder;
  408.     }
  410.     public function setReminder(int $reminder): self
  411.     {
  412.         $this->reminder = $reminder;
  414.         return $this;
  415.     }
  417.     public function getLastReminder(): ?\DateTimeInterface
  418.     {
  419.         return $this->lastReminder;
  420.     }
  422.     public function setLastReminder(?\DateTimeInterface $lastReminder): self
  423.     {
  424.         $this->lastReminder = $lastReminder;
  426.         return $this;
  427.     }
  429.     public function getDiffSinceLastReminder(): ?DateInterval
  430.     {
  431.         $reminder = $this->getLastReminder() ?? $this->getUpdatedAt() ?? new DateTimeImmutable();
  432.         $now = new DateTimeImmutable();
  434.         return $reminder->diff($now);
  435.     }
  437.     public function getOrigin(): ?RegistrationOrigin
  438.     {
  439.         return $this->origin;
  440.     }
  442.     public function setOrigin(RegistrationOrigin $origin): self
  443.     {
  444.         $this->origin = $origin;
  446.         return $this;
  447.     }
  449.     public function guessPaymentType($printable = false): ?string
  450.     {
  451.         $transaction = $this->getOrder()->getTransactions(statuses: [
  452.             TransactionStatus::Created,
  453.             TransactionStatus::Waiting,
  454.             TransactionStatus::Successful,
  455.         ])->first();
  457.         if ($transaction) {
  458.             $class = get_class($transaction);
  459.             if ($printable && Transaction::getNameByClass($class)) {
  460.                 return Transaction::getNameByClass($class);
  461.             }
  463.             return $class;
  464.         }
  466.         return null;
  467.     }
  469.     public function __clone()
  470.     {
  471.         $this->uuid = null;
  472.         $this->id = null;
  473.         $this->__construct();
  474.         $this->status = RegistrationStatus::Prospect;
  475.         $this->hasTaxReceipt = null;
  476.         $this->hasCompanyReceipt = null;
  477.         $this->signatory = null;
  478.         $this->lesson = null;
  479.         $this->season = null;
  480.         $this->validationStep = 1;
  481.         $this->reminder = 0;
  482.         $this->createdAt = null;
  483.         $this->updatedAt = null;
  484.     }
  485. }