src/Entity/Order.php line 17

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use App\Repository\OrderRepository;
  7. use App\Traits\Timestamps;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\DBAL\Types\Types;
  11. use Doctrine\ORM\Mapping as ORM;
  13. #[ORM\Entity(repositoryClass: OrderRepository::class)]
  14. #[ORM\Table(name: '`order`')]
  15. #[ApiResource()]
  16. #[ORM\HasLifecycleCallbacks]
  17. class Order
  18. {
  19.     use Timestamps;
  20.     
  21.     /**
  22.      * Statuts possibles pour une commande
  23.      */
  24.     public const STATUS_PENDING = 'pending';
  25.     public const STATUS_CONFIRMED = 'confirmed';
  26.     public const STATUS_CANCELLED = 'cancelled';
  27.     public const STATUS_UNPAID = 'unpaid';
  28.     
  29.     /**
  30.      * Liste des statuts disponibles
  31.      */
  32.     public const STATUSES = [
  33.         'En attente' => self::STATUS_PENDING,
  34.         'Confirmé' => self::STATUS_CONFIRMED,
  35.         'Annulé' => self::STATUS_CANCELLED,
  36.         'Impayé' => self::STATUS_UNPAID
  37.     ];
  39.     #[ORM\Id]
  40.     #[ORM\GeneratedValue]
  41.     #[ORM\Column]
  42.     private ?int $id = null;
  44.     #[ORM\ManyToOne(fetch: 'EAGER', inversedBy: 'orders')]
  45.     #[ORM\JoinColumn(nullable: false)]
  46.     private ?Client $client = null;
  48.     #[ORM\ManyToOne(fetch: 'EAGER')]
  49.     #[ORM\JoinColumn(nullable: false)]
  50.     private ?Plan $plan = null;
  52.     #[ORM\Column(type: Types::DECIMAL, precision: 10, scale: 2)]
  53.     private ?string $price = null;
  55.     #[ORM\Column(type: Types::DATE_MUTABLE)]
  56.     private ?\DateTimeInterface $startDate = null;
  58.     #[ORM\Column(type: Types::DATE_MUTABLE)]
  59.     private ?\DateTimeInterface $endDate = null;
  61.     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => false])]
  62.     private bool $autoRenew = false;
  64.     #[ORM\ManyToMany(targetEntity: Plan::class)]
  65.     #[ORM\JoinTable(name: 'order_extra_services')]
  66.     private Collection $extraServices;
  67.     
  68.     #[ORM\Column(length: 20)]
  69.     private ?string $status = self::STATUS_PENDING;
  71.     #[ORM\OneToMany(mappedBy: 'order', targetEntity: Payment::class, cascade: ['persist', 'remove'])]
  72.     private Collection $payments;
  74.     /**
  75.      * Référence de la commande - par INKY
  76.      */
  77.     #[ORM\Column(length: 255, nullable: true)]
  78.     private ?string $orderReference = null;
  80.     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => false])]
  81.     private bool $annualPayment = false;
  83.     public function getId(): ?int
  84.     {
  85.         return $this->id;
  86.     }
  88.     public function getClient(): ?Client
  89.     {
  90.         return $this->client;
  91.     }
  93.     public function setClient(?Client $client): static
  94.     {
  95.         $this->client = $client;
  96.         return $this;
  97.     }
  99.     public function getPlan(): ?Plan
  100.     {
  101.         return $this->plan;
  102.     }
  104.     public function setPlan(?Plan $plan): static
  105.     {
  106.         $this->plan = $plan;
  107.         $this->setPrice($plan->getPrice());
  108.         return $this;
  109.     }
  111.     public function getPrice(): ?string
  112.     {
  113.         return $this->price;
  114.     }
  116.     public function setPrice(string $price): static
  117.     {
  118.         $this->price = $price;
  119.         return $this;
  120.     }
  122.     public function getStartDate(): ?\DateTimeInterface
  123.     {
  124.         return $this->startDate;
  125.     }
  127.     public function setStartDate(\DateTimeInterface $startDate): static
  128.     {
  129.         $this->startDate = $startDate;
  130.         return $this;
  131.     }
  133.     public function getEndDate(): ?\DateTimeInterface
  134.     {
  135.         return $this->endDate;
  136.     }
  138.     public function setEndDate(\DateTimeInterface $endDate): static
  139.     {
  140.         $this->endDate = $endDate;
  141.         return $this;
  142.     }
  144.     public function isAutoRenew(): bool
  145.     {
  146.         return $this->autoRenew;
  147.     }
  149.     public function setAutoRenew(bool $autoRenew): static
  150.     {
  151.         $this->autoRenew = $autoRenew;
  152.         return $this;
  153.     }
  155.     public function __construct()
  156.     {
  157.         $this->extraServices = new ArrayCollection();
  158.         $this->payments = new ArrayCollection();
  159.     }
  161.     /**
  162.      * @return Collection<int, Plan>
  163.      */
  164.     public function getExtraServices(): Collection
  165.     {
  166.         return $this->extraServices;
  167.     }
  169.     public function addExtraService(Plan $extraService): static
  170.     {
  171.         if (!$this->extraServices->contains($extraService)) {
  172.             $this->extraServices->add($extraService);
  173.         }
  175.         return $this;
  176.     }
  178.     public function removeExtraService(Plan $extraService): static
  179.     {
  180.         $this->extraServices->removeElement($extraService);
  182.         return $this;
  183.     }
  184.     
  185.     public function getStatus(): ?string
  186.     {
  187.         return $this->status;
  188.     }
  190.     public function setStatus(string $status): static
  191.     {
  192.         if (!in_array($status, [self::STATUS_PENDING, self::STATUS_CONFIRMED, self::STATUS_CANCELLED, self::STATUS_UNPAID])) {
  193.             throw new \InvalidArgumentException(sprintf(
  194.                 'Statut invalide "%s". Les statuts autorisés sont : %s',
  195.                 $status,
  196.                 implode(', ', [self::STATUS_PENDING, self::STATUS_CONFIRMED, self::STATUS_CANCELLED, self::STATUS_UNPAID])
  197.             ));
  198.         }
  199.         
  200.         $this->status = $status;
  201.         return $this;
  202.     }
  203.     
  204.     /**
  205.      * @return bool
  206.      */
  207.     public function isPending(): bool
  208.     {
  209.         return $this->status === self::STATUS_PENDING;
  210.     }
  211.     
  212.     /**
  213.      * @return bool
  214.      */
  215.     public function isConfirmed(): bool
  216.     {
  217.         return $this->status === self::STATUS_CONFIRMED;
  218.     }
  219.     
  220.     /**
  221.      * @return bool
  222.      */
  223.     public function isCancelled(): bool
  224.     {
  225.         return $this->status === self::STATUS_CANCELLED;
  226.     }
  227.     
  228.     /**
  229.      * @return bool
  230.      */
  231.     public function isUnpaid(): bool
  232.     {
  233.         return $this->status === self::STATUS_UNPAID;
  234.     }
  236.     /**
  237.      * @return Collection<int, Payment>
  238.      */
  239.     public function getPayments(): Collection
  240.     {
  241.         return $this->payments;
  242.     }
  244.     public function addPayment(Payment $payment): static
  245.     {
  246.         if (!$this->payments->contains($payment)) {
  247.             $this->payments->add($payment);
  248.             $payment->setOrder($this);
  249.         }
  251.         return $this;
  252.     }
  254.     public function removePayment(Payment $payment): static
  255.     {
  256.         if ($this->payments->removeElement($payment)) {
  257.             // Set the owning side to null (unless already changed)
  258.             if ($payment->getOrder() === $this) {
  259.                 $payment->setOrder(null);
  260.             }
  261.         }
  263.         return $this;
  264.     }
  266.     /**
  267.      * Récupère le dernier paiement (le plus récent)
  268.      */
  269.     public function getLatestPayment(): ?Payment
  270.     {
  271.         if ($this->payments->isEmpty()) {
  272.             return null;
  273.         }
  275.         $payments = $this->payments->toArray();
  276.         usort($payments, function(Payment $a, Payment $b) {
  277.             return $b->getCreatedAt() <=> $a->getCreatedAt();
  278.         });
  280.         return $payments[0];
  281.     }
  283.     /**
  284.      * Récupère le premier paiement confirmé
  285.      */
  286.     public function getConfirmedPayment(): ?Payment
  287.     {
  288.         foreach ($this->payments as $payment) {
  289.             if ($payment->isConfirmed()) {
  290.                 return $payment;
  291.             }
  292.         }
  293.         return null;
  294.     }
  296.     /**
  297.      * Méthode de compatibilité pour récupérer l'ID de paiement Konnect du dernier paiement
  298.      */
  299.     public function getPaymentId(): ?string
  300.     {
  301.         $latestPayment = $this->getLatestPayment();
  302.         return $latestPayment?->getKonnectPaymentId();
  303.     }
  305.     /**
  306.      * Méthode de compatibilité pour créer un nouveau paiement avec l'ID Konnect
  307.      */
  308.     public function setPaymentId(?string $konnectPaymentId): static
  309.     {
  310.         if ($konnectPaymentId === null) {
  311.             return $this;
  312.         }
  314.         $payment = new Payment();
  315.         $payment->setKonnectPaymentId($konnectPaymentId);
  316.         $payment->setAmount($this->getPrice());
  317.         $payment->setStatus(Payment::STATUS_PENDING);
  318.         
  319.         $this->addPayment($payment);
  320.         return $this;
  321.     }
  323.     /**
  324.      * Référence de la commande - par INKY
  325.      */
  326.     public function getOrderReference(): ?string
  327.     {
  328.         return $this->orderReference;
  329.     }
  331.     /**
  332.      * Référence de la commande - par INKY
  333.      */
  334.     public function setOrderReference(?string $orderReference): static
  335.     {
  336.         $this->orderReference = $orderReference;
  337.         return $this;
  338.     }
  340.     public function isAnnualPayment(): bool
  341.     {
  342.         return $this->annualPayment;
  343.     }
  345.     public function setAnnualPayment(bool $annualPayment): static
  346.     {
  347.         $this->annualPayment = $annualPayment;
  348.         return $this;
  349.     }
  351.     /**
  352.      * Génère automatiquement une référence de commande avant la persistance
  353.      */
  354.     #[ORM\PrePersist]
  355.     public function generateOrderReferenceOnPrePersist(): void
  356.     {
  357.         if ($this->orderReference === null) {
  358.             $date = new \DateTime();
  359.             $timestamp = $date->format('YmdHis');
  360.             $this->orderReference = "ORD-$timestamp";
  361.         }
  362.     }
  363. }