src/Entity/Client.php line 42

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use ApiPlatform\Metadata\GetCollection;
  7. use ApiPlatform\Metadata\Get;
  8. use ApiPlatform\Metadata\Post;
  9. use App\Controller\Api\Client\ApiClientInvoicesController;
  10. use App\Kimia;
  11. use App\Model\Wallet\WalletInterface;
  12. use App\Repository\ClientRepository;
  13. use App\Service\GeoIP;
  14. use App\Trait\ActivableTrait;
  15. use App\Trait\ArrayableTrait;
  16. use App\Trait\DateTrait;
  17. use App\Trait\DeletableTrait;
  18. use App\Trait\WalletTrait;
  19. use DateTimeImmutable;
  20. use Doctrine\Common\Collections\ArrayCollection;
  21. use Doctrine\Common\Collections\Collection;
  22. use Doctrine\ORM\Mapping as ORM;
  23. use Symfony\Component\Serializer\Annotation\Groups;
  25. #[ORM\Entity(repositoryClass: ClientRepository::class)]
  26. #[ApiResource(
  27.     operations: [
  28.         new GetCollection(
  29.             normalizationContext: ['groups' => ['client:list']]
  30.         ),
  31.         new Get(),
  32.         new Post(
  33.             uriTemplate: "/clients/invoices",
  34.             controller: ApiClientInvoicesController::class,
  35.             normalizationContext: ['groups' => ['client:list', 'client:invoices']],
  36.             denormalizationContext: ['groups' => ['client:invoices:get']],
  37.             write: false,
  38.         )
  39.     ],
  40.     normalizationContext: ['groups' => ['client:list', 'client:view']]
  41. )]
  42. class Client implements WalletInterface
  43. {
  44.     use ArrayableTrait;
  45.     use DateTrait {__construct as private constructDate;}
  46.     use ActivableTrait;
  47.     use DeletableTrait;
  48.     use WalletTrait;
  50.     #[ORM\Id]
  51.     #[ORM\GeneratedValue]
  52.     #[ORM\Column]
  53.     #[Groups(['client:list', 'client:invoices', 'attendance:list'])]
  54.     private ?int $id = null;
  56.     #[ORM\Column(length: 255)]
  57.     #[Groups(['client:list', 'order:list', 'attendance:list'])]
  58.     private ?string $firstname = null;
  60.     #[ORM\Column(length: 255, nullable: true)]
  61.     #[Groups(['client:list', 'order:list', 'attendance:list'])]
  62.     private ?string $lastname = null;
  64.     #[ORM\Column(length: 180, nullable: true)]
  65.     #[Groups(['client:list', 'order:view', 'attendance:list'])]
  66.     private ?string $email = null;
  68.     #[ORM\Column(length: 15, nullable: true)]
  69.     #[Groups(['client:list', 'order:view', 'attendance:list'])]
  70.     private ?string $phone = null;
  72.     #[ORM\Column(length: 255, nullable: true)]
  73.     #[Groups(['client:list', 'order:view'])]
  74.     private ?string $comment = null;
  76.     #[ORM\ManyToOne(inversedBy: 'clients')]
  77.     #[ORM\JoinColumn(nullable: true)]
  78.     private ?Department $department = null;
  80.     #[ORM\ManyToOne(inversedBy: 'clients')]
  81.     #[ORM\JoinColumn(nullable: false)]
  82.     private ?Establishment $establishment = null;
  84.     #[ORM\ManyToMany(targetEntity: Order::class, mappedBy: 'clients')]
  85.     private Collection $orders;
  87.     #[ORM\Column]
  88.     private ?int $quota = 0;
  90.     #[ORM\Column(options: ['default' => true])]
  91.     private ?bool $isTaxable = true;
  93.     #[ORM\Column(length: 255, nullable: true)]
  94.     #[Groups(['client:invoices:get'])]
  95.     private ?string $ref = null;
  97.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Invoice::class)]
  98.     #[Groups(['client:invoices'])]
  99.     private Collection $invoices;
  101.     #[ORM\ManyToOne(cascade: ["persist"])]
  102.     #[ORM\JoinColumn(nullable: true)]
  103.     private ?Attachment $thumbnail = null;
  105.     #[ORM\Column(length: 2, nullable: true)]
  106.     private ?string $country;
  108.     #[ORM\Column(length: 255, nullable: true)]
  109.     private ?string $name = null;
  111.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Address::class, cascade: ['persist'])]
  112.     private Collection $addresses;
  114.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Document::class, cascade: ['persist'])]
  115.     private Collection $documents;
  117.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Mutuality::class)]
  118.     private Collection $mutualities;
  120.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Attendance::class)]
  121.     private Collection $attendances;
  123.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Card::class)]
  124.     private Collection $cards;
  126.     #[ORM\Column(length: 255, nullable: true)]
  127.     private ?string $city = null;
  129.     public function __construct()
  130.     {
  131.         $this->constructDate();
  132.         $this->isActive = Kimia::ACTIVE;
  133.         $this->orders = new ArrayCollection();
  134.         $this->invoices = new ArrayCollection();
  135.         $this->addresses = new ArrayCollection();
  136.         $this->country = 'CD';
  137.         $this->documents = new ArrayCollection();
  138.         $this->mutualities = new ArrayCollection();
  139.         $this->attendances = new ArrayCollection();
  140.         $this->cards = new ArrayCollection();
  141.         $this->ordersList = new ArrayCollection();
  142.     }
  144.     public function getId(): ?int
  145.     {
  146.         return $this->id;
  147.     }
  149.     public function getFullname(): ?string
  150.     {
  151.         return "$this->firstname $this->lastname";
  152.     }
  154.     public function getFirstname(): ?string
  155.     {
  156.         return $this->firstname;
  157.     }
  159.     public function setFirstname(string $firstname): self
  160.     {
  161.         $this->firstname = $firstname;
  163.         return $this;
  164.     }
  166.     public function getLastname(): ?string
  167.     {
  168.         return $this->lastname;
  169.     }
  171.     public function setLastname(?string $lastname): self
  172.     {
  173.         $this->lastname = $lastname;
  175.         return $this;
  176.     }
  178.     public function getEmail(): ?string
  179.     {
  180.         return $this->email;
  181.     }
  183.     public function setEmail(?string $email): self
  184.     {
  185.         $this->email = $email;
  187.         return $this;
  188.     }
  190.     public function getPhone(): ?string
  191.     {
  192.         return $this->phone;
  193.     }
  195.     public function setPhone(?string $phone): self
  196.     {
  197.         $this->phone = GeoIP::phoneResolve($phone, $this->country);
  199.         return $this;
  200.     }
  202.     public function getComment(): ?string
  203.     {
  204.         return $this->comment;
  205.     }
  207.     public function setComment(?string $comment): self
  208.     {
  209.         $this->comment = $comment;
  211.         return $this;
  212.     }
  214.     public function __toString(): string
  215.     {
  216.         return $this->getName() ?? $this->getEmail() ?? $this->getPhone() ?? "";
  217.     }
  219.     public function getDepartment(): ?Department
  220.     {
  221.         return $this->department;
  222.     }
  224.     public function setDepartment(?Department $department): self
  225.     {
  226.         $this->department = $department;
  228.         return $this;
  229.     }
  231.     public function getEstablishment(): ?Establishment
  232.     {
  233.         return $this->establishment;
  234.     }
  236.     public function setEstablishment(?Establishment $establishment): self
  237.     {
  238.         $this->establishment = $establishment;
  240.         return $this;
  241.     }
  243.     public function getQuota(): ?int
  244.     {
  245.         return $this->quota;
  246.     }
  248.     public function setQuota(int $quota): self
  249.     {
  250.         $this->quota = $quota;
  252.         return $this;
  253.     }
  256.     public function incrementQuota(int $quota = 1): self
  257.     {
  258.         $this->quota += $quota;
  259.         return $this;
  260.     }
  262.     public function decrementQuota(): void
  263.     {
  264.         $this->quota = $this->getQuota() - 1;
  265.     }
  267.     public function isIsTaxable(): ?bool
  268.     {
  269.         return $this->isTaxable;
  270.     }
  272.     public function setIsTaxable(bool $isTaxable): self
  273.     {
  274.         $this->isTaxable = $isTaxable;
  276.         return $this;
  277.     }
  279.     public function getRef(): ?string
  280.     {
  281.         return $this->ref;
  282.     }
  284.     public function setRef(?string $ref): static
  285.     {
  286.         $this->ref = $ref;
  288.         return $this;
  289.     }
  291.     /**
  292.      * @return Collection<int, Invoice>
  293.      */
  294.     public function getInvoices(): Collection
  295.     {
  296.         return $this->invoices;
  297.     }
  299.     public function addInvoice(Invoice $invoice): static
  300.     {
  301.         if (!$this->invoices->contains($invoice)) {
  302.             $this->invoices->add($invoice);
  303.             $invoice->setClient($this);
  304.         }
  306.         return $this;
  307.     }
  309.     public function removeInvoice(Invoice $invoice): static
  310.     {
  311.         if ($this->invoices->removeElement($invoice)) {
  312.             // set the owning side to null (unless already changed)
  313.             if ($invoice->getClient() === $this) {
  314.                 $invoice->setClient(null);
  315.             }
  316.         }
  318.         return $this;
  319.     }
  322.     public function getThumbnail(): ?Attachment
  323.     {
  324.         return $this->thumbnail;
  325.     }
  327.     public function setThumbnail(?Attachment $thumbnail): self
  328.     {
  329.         $this->thumbnail = $thumbnail;
  331.         return $this;
  332.     }
  334.     public function getCountry(): ?string
  335.     {
  336.         return $this->country;
  337.     }
  339.     public function setCountry(?string $country): static
  340.     {
  341.         $this->country = $country;
  343.         return $this;
  344.     }
  346.     public function getName(): ?string
  347.     {
  348.         return $this->name;
  349.     }
  351.     public function setName(?string $name): static
  352.     {
  353.         $this->name = $name;
  355.         return $this;
  356.     }
  358.     /**
  359.      * @return Collection<int, Address>
  360.      */
  361.     public function getAddresses(): Collection
  362.     {
  363.         return $this->addresses;
  364.     }
  366.     public function addAddress(Address $address): static
  367.     {
  368.         if (!$this->addresses->contains($address)) {
  369.             $this->addresses->add($address);
  370.             $address->setClient($this);
  371.         }
  373.         return $this;
  374.     }
  376.     public function removeAddress(Address $address): static
  377.     {
  378.         if ($this->addresses->removeElement($address)) {
  379.             // set the owning side to null (unless already changed)
  380.             if ($address->getClient() === $this) {
  381.                 $address->setClient(null);
  382.             }
  383.         }
  385.         return $this;
  386.     }
  388.     /**
  389.      * @return Collection<int, Document>
  390.      */
  391.     public function getDocuments(): Collection
  392.     {
  393.         return $this->documents;
  394.     }
  396.     public function addDocument(Document $document): static
  397.     {
  398.         if (!$this->documents->contains($document)) {
  399.             $this->documents->add($document);
  400.             $document->setClient($this);
  401.         }
  403.         return $this;
  404.     }
  406.     public function removeDocument(Document $document): static
  407.     {
  408.         if ($this->documents->removeElement($document)) {
  409.             // set the owning side to null (unless already changed)
  410.             if ($document->getClient() === $this) {
  411.                 $document->setClient(null);
  412.             }
  413.         }
  415.         return $this;
  416.     }
  418.     /**
  419.      * @return Collection<int, Mutuality>
  420.      */
  421.     public function getMutualities(): Collection
  422.     {
  423.         return $this->mutualities;
  424.     }
  426.     public function addMutuality(Mutuality $mutuality): static
  427.     {
  428.         if (!$this->mutualities->contains($mutuality)) {
  429.             $this->mutualities->add($mutuality);
  430.             $mutuality->setClient($this);
  431.         }
  433.         return $this;
  434.     }
  436.     public function removeMutuality(Mutuality $mutuality): static
  437.     {
  438.         if ($this->mutualities->removeElement($mutuality)) {
  439.             // set the owning side to null (unless already changed)
  440.             if ($mutuality->getClient() === $this) {
  441.                 $mutuality->setClient(null);
  442.             }
  443.         }
  445.         return $this;
  446.     }
  448.     /**
  449.      * @return Collection<int, Attendance>
  450.      */
  451.     public function getAttendances(): Collection
  452.     {
  453.         return $this->attendances;
  454.     }
  456.     public function addAttendance(Attendance $attendance): static
  457.     {
  458.         if (!$this->attendances->contains($attendance)) {
  459.             $this->attendances->add($attendance);
  460.             $attendance->setClient($this);
  461.         }
  463.         return $this;
  464.     }
  466.     public function removeAttendance(Attendance $attendance): static
  467.     {
  468.         if ($this->attendances->removeElement($attendance)) {
  469.             // set the owning side to null (unless already changed)
  470.             if ($attendance->getClient() === $this) {
  471.                 $attendance->setClient(null);
  472.             }
  473.         }
  475.         return $this;
  476.     }
  478.     /**
  479.      * @return Collection<int, Card>
  480.      */
  481.     public function getCards(): Collection
  482.     {
  483.         return $this->cards;
  484.     }
  486.     public function addCard(Card $card): static
  487.     {
  488.         if (!$this->cards->contains($card)) {
  489.             $this->cards->add($card);
  490.             $card->setClient($this);
  491.         }
  493.         return $this;
  494.     }
  496.     public function removeCard(Card $card): static
  497.     {
  498.         if ($this->cards->removeElement($card)) {
  499.             // set the owning side to null (unless already changed)
  500.             if ($card->getClient() === $this) {
  501.                 $card->setClient(null);
  502.             }
  503.         }
  505.         return $this;
  506.     }
  508.     public function getCity(): ?string
  509.     {
  510.         return $this->city;
  511.     }
  513.     public function setCity(?string $city): static
  514.     {
  515.         $this->city = $city;
  517.         return $this;
  518.     }
  520.     /**
  521.      * @return Collection<int, Order>
  522.      */
  523.     public function getOrders(): Collection
  524.     {
  525.         return $this->ordersList;
  526.     }
  528.     public function addOrders(Order $orders): static
  529.     {
  530.         if (!$this->ordersList->contains($orders)) {
  531.             $this->ordersList->add($orders);
  532.             $orders->addClient($this);
  533.         }
  535.         return $this;
  536.     }
  538.     public function removeOrders(Order $orders): static
  539.     {
  540.         if ($this->ordersList->removeElement($orders)) {
  541.             $orders->removeClient($this);
  542.         }
  544.         return $this;
  545.     }
  546. }