src/Entity/Order.php line 75

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\Link;
  6. use App\Controller\Api\Order\ApiEstablishmentOrderInvoiceController;
  7. use App\Controller\Api\Order\ApiOrderShipmentTimerController;
  8. use App\Dto\CreateOrderInput;
  9. use App\Kimia;
  10. use ApiPlatform\Metadata\ApiResource;
  11. use ApiPlatform\Metadata\Get;
  12. use ApiPlatform\Metadata\GetCollection;
  13. use ApiPlatform\Metadata\Post;
  14. use App\Controller\Api\Order\ApiEstablishmentOrderNewController;
  15. use App\Controller\Api\Order\ApiOrderShipmentOverController;
  16. use App\Controller\Api\Order\ApiOrderShipmentStartController;
  17. use App\Repository\OrderRepository;
  18. use App\State\Order\OrderCreateProcessor;
  19. use App\Trait\ArrayableTrait;
  20. use App\Trait\CurrentStateTrait;
  21. use App\Trait\DateTrait;
  22. use DateTimeImmutable;
  23. use Doctrine\Common\Collections\ArrayCollection;
  24. use Doctrine\Common\Collections\Collection;
  25. use Doctrine\ORM\Mapping as ORM;
  26. use Symfony\Component\Serializer\Annotation\Groups;
  28. #[ORM\Entity(repositoryClass: OrderRepository::class)]
  29. #[ORM\Table(name: '`order`')]
  30. #[ApiResource(
  31.     operations: [
  32.         new GetCollection(
  33.             normalizationContext: ['groups' => ['order:list']]
  34.         ),
  35.         new GetCollection(
  36.             uriTemplate: "/departments/{departmentId}/orders",
  37.             uriVariables: [
  38.                 'departmentId' => new Link(toProperty: 'department', fromClass: Department::class),
  39.             ],
  40.             normalizationContext: ['groups' => ['order:list']]
  41.         ),
  42.         new GetCollection(
  43.             uriTemplate: "/employees/{waiterId}/orders",
  44.             uriVariables: [
  45.                 'waiterId' => new Link(toProperty: 'waiter', fromClass: Employee::class),
  46.             ],
  47.             normalizationContext: ['groups' => ['order:list']]
  48.         ),
  49.         new Get(),
  50.         new Get(
  51.             uriTemplate: "/orders/{id}/invoice",
  52.             controller: ApiEstablishmentOrderInvoiceController::class,
  53.         ),
  54.         new Get(
  55.             uriTemplate: "/orders/{id}/timer",
  56.             controller: ApiOrderShipmentTimerController::class,
  57.             normalizationContext: ['groups' => ['order:timer']]
  58.         ),
  59.         new Post(
  60.             input: CreateOrderInput::class,
  61.             processor: OrderCreateProcessor::class
  62.         ),
  63.         new Post(
  64.             uriTemplate: "/orders/{id}/start",
  65.             controller: ApiOrderShipmentStartController::class,
  66.         ),
  67.         new Post(
  68.             uriTemplate: "/orders/{id}/over",
  69.             controller: ApiOrderShipmentOverController::class,
  70.         ),
  71.     ],
  72.     normalizationContext: ['groups' => ['order:list', 'order:view']],
  73.     paginationClientEnabled: true
  74. )]
  75. class Order
  76. {
  77.     use ArrayableTrait;
  78.     use DateTrait;
  79.     use CurrentStateTrait;
  81.     #[ORM\Id]
  82.     #[ORM\GeneratedValue]
  83.     #[ORM\Column]
  84.     #[Groups(['order:list'])]
  85.     private ?int $id = null;
  87.     #[ORM\Column(length: 255)]
  88.     #[Groups(['order:list'])]
  89.     private ?string $reference = null;
  91.     #[ORM\Column(length: 255, nullable: true)]
  92.     #[Groups(['order:list'])]
  93.     private ?string $name = null;
  95.     #[ORM\Column(length: 255, nullable: true)]
  96.     #[Groups(['order:list'])]
  97.     private ?string $phone = null;
  99.     #[ORM\Column]
  100.     #[Groups(['order:list'])]
  101.     private ?float $amount = null;
  103.     #[ORM\Column(nullable: true)]
  104.     #[Groups(['order:list'])]
  105.     private ?float $payout = null;
  107.     #[ORM\Column(length: 255)]
  108.     #[Groups(['order:list'])]
  109.     private ?string $method = null;
  111.     #[ORM\Column]
  112.     #[Groups(['order:list'])]
  113.     private ?int $status = null;
  115.     #[ORM\OneToMany(mappedBy: 'command', targetEntity: OrderItems::class, cascade: ["persist"], orphanRemoval: true)]
  116.     #[Groups(['order:list'])]
  117.     private Collection $orderItems;
  119.     #[ORM\ManyToOne(inversedBy: 'orders')]
  120.     #[ORM\JoinColumn(nullable: true)]
  121.     #[Groups(['order:list'])]
  122.     private ?Department $department = null;
  124.     #[ORM\OneToMany(mappedBy: 'command', targetEntity: Invoice::class, cascade: ["persist"], orphanRemoval: true)]
  125.     private Collection $invoice;
  127.     #[ORM\ManyToOne]
  128.     #[ORM\JoinColumn(nullable: false)]
  129.     #[Groups(['order:list'])]
  130.     private ?Currency $currency = null;
  132.     #[ORM\ManyToOne]
  133.     #[ORM\JoinColumn(nullable: false)]
  134.     private ?User $author = null;
  136.     #[ORM\ManyToOne(inversedBy: 'orders')]
  137.     #[Groups(['order:view'])]
  138.     private ?Employee $waiter = null;
  140.     #[ORM\Column]
  141.     #[Groups(['order:view'])]
  142.     private ?bool $isDeliverable;
  144.     #[ORM\ManyToOne]
  145.     #[ORM\JoinColumn(nullable: false)]
  146.     #[Groups(['order:view'])]
  147.     private ?Rate $rate = null;
  149.     #[ORM\OneToMany(mappedBy: 'command', targetEntity: Shipment::class, orphanRemoval: true)]
  150.     #[Groups(['order:list', 'order:view'])]
  151.     private Collection $shipment;
  153.     #[ORM\ManyToOne(inversedBy: 'orders')]
  154.     #[ORM\JoinColumn(nullable: false)]
  155.     private ?Establishment $establishment = null;
  157.     #[ORM\Column(options: ['default' => false])]
  158.     private ?bool $isProforma = false;
  160.     #[ORM\OneToOne(mappedBy: 'orderCommand', cascade: ['persist', 'remove'])]
  161.     private ?Transaction $transaction = null;
  163.     #[ORM\ManyToMany(targetEntity: Client::class, inversedBy: 'orders')]
  164.     #[Groups(['order:list'])]
  165.     private Collection $clients;
  167.     #[ORM\Column(options: ['default' => 1])]
  168.     private ?int $clientPrincipalI = 1;
  170.     public function __construct()
  171.     {
  172.         $this->currentState = 'new';
  173.         $this->isDeliverable = 0;
  174.         if (is_null($this->reference)) $this->reference = strtoupper(uniqid('OD-'));
  175.         if (is_null($this->createdAt)) $this->createdAt = new DateTimeImmutable();
  176.         $this->updatedAt = new DateTimeImmutable();
  177.         $this->orderItems = new ArrayCollection();
  178.         $this->invoice = new ArrayCollection();
  179.         $this->shipment = new ArrayCollection();
  180.         $this->status = Kimia::STATUS_INIT;
  181.         $this->clients = new ArrayCollection();
  182.     }
  184.     public function getId(): ?int
  185.     {
  186.         return $this->id;
  187.     }
  189.     public function getReference(): ?string
  190.     {
  191.         return $this->reference;
  192.     }
  194.     public function setReference(string $reference): self
  195.     {
  196.         $this->reference = $reference;
  198.         return $this;
  199.     }
  201.     public function getName(): ?string
  202.     {
  203.         return $this->name;
  204.     }
  206.     public function setName(?string $name): self
  207.     {
  208.         $this->name = $name;
  210.         return $this;
  211.     }
  213.     public function getPhone(): ?string
  214.     {
  215.         return $this->phone;
  216.     }
  218.     public function setPhone(?string $phone): self
  219.     {
  220.         $this->phone = $phone;
  222.         return $this;
  223.     }
  225.     public function getAmount(): ?float
  226.     {
  227.         return $this->amount;
  228.     }
  230.     public function getAmountRest(): ?float
  231.     {
  232.         return $this->amount - $this->getPayout();
  233.     }
  235.     public function setAmount(float $amount): self
  236.     {
  237.         $this->amount = $amount;
  239.         return $this;
  240.     }
  242.     public function getPayout(): ?float
  243.     {
  244.         //return count($this->invoice) != 0 ? $this->amount - $this->getAmountRest() : $this->payout;
  245.         return $this->payout;
  246.     }
  248.     public function setPayout(?float $payout): self
  249.     {
  250.         $this->payout = $payout;
  252.         return $this;
  253.     }
  255.     public function getMethod(): ?string
  256.     {
  257.         return $this->method;
  258.     }
  260.     public function setMethod(string $method): self
  261.     {
  262.         $this->method = $method;
  264.         return $this;
  265.     }
  267.     public function getStatus(): ?int
  268.     {
  269.         return $this->status;
  270.     }
  272.     public static function getStatusListForView(): array
  273.     {
  274.         return [
  275.             Kimia::STATUS_INIT => "<span class='badge badge-soft-info'>Initié</span>",
  276.             Kimia::STATUS_ACCEPTED => "<span class='badge badge-soft-info'>Accepté</span>",
  277.             Kimia::STATUS_SUCCESS => "<span class='badge badge-soft-success'>Succès</span>",
  278.             Kimia::STATUS_PROCESS => "<span class='badge badge-soft-warning'>En cours</span>",
  279.             Kimia::STATUS_ERROR => "<span class='badge badge-soft-danger'>Erreur</span>",
  280.             Kimia::STATUS_CANCEL => "<span class='badge badge-soft-secondary'>Annulé</span>",
  281.             Kimia::STATUS_FAILED => "<span class='badge badge-soft-secondary'>Échoué</span>",
  282.             Kimia::STATUS_PROFORMA => "<span class='badge badge-soft-warning'>Proforma</span>",
  283.         ];
  284.     }
  286.     public function setStatus(int $status): self
  287.     {
  288.         $this->status = $status;
  290.         return $this;
  291.     }
  293.     /**
  294.      * @return Collection<int, OrderItems>
  295.      */
  296.     public function getOrderItems(): Collection
  297.     {
  298.         return $this->orderItems;
  299.     }
  301.     public function addOrderItem(OrderItems $orderItem): self
  302.     {
  303.         if (!$this->orderItems->contains($orderItem)) {
  304.             $this->orderItems->add($orderItem);
  305.             $orderItem->setCommand($this);
  306.         }
  308.         return $this;
  309.     }
  311.     public function removeOrderItem(OrderItems $orderItem): self
  312.     {
  313.         if ($this->orderItems->removeElement($orderItem)) {
  314.             // set the owning side to null (unless already changed)
  315.             if ($orderItem->getCommand() === $this) {
  316.                 $orderItem->setCommand(null);
  317.             }
  318.         }
  320.         return $this;
  321.     }
  323.     public function getDepartment(): ?Department
  324.     {
  325.         return $this->department;
  326.     }
  328.     public function setDepartment(?Department $department): self
  329.     {
  330.         $this->department = $department;
  332.         return $this;
  333.     }
  335.     /**
  336.      * @return Collection<int, Invoice>
  337.      */
  338.     public function getInvoice(): Collection
  339.     {
  340.         return $this->invoice;
  341.     }
  343.     public function addInvoice(Invoice $invoice): self
  344.     {
  345.         if (!$this->invoice->contains($invoice)) {
  346.             $this->invoice->add($invoice);
  347.             $invoice->setCommand($this);
  348.         }
  350.         return $this;
  351.     }
  353.     public function removeInvoice(Invoice $invoice): self
  354.     {
  355.         if ($this->invoice->removeElement($invoice)) {
  356.             // set the owning side to null (unless already changed)
  357.             if ($invoice->getCommand() === $this) {
  358.                 $invoice->setCommand(null);
  359.             }
  360.         }
  362.         return $this;
  363.     }
  365.     public function getCurrency(): ?Currency
  366.     {
  367.         return $this->currency;
  368.     }
  370.     public function setCurrency(?Currency $currency): self
  371.     {
  372.         $this->currency = $currency;
  374.         return $this;
  375.     }
  377.     public function getAuthor(): ?User
  378.     {
  379.         return $this->author;
  380.     }
  382.     public function setAuthor(?User $author): self
  383.     {
  384.         $this->author = $author;
  386.         return $this;
  387.     }
  389.     public function getWaiter(): ?Employee
  390.     {
  391.         return $this->waiter;
  392.     }
  394.     public function setWaiter(?Employee $waiter): self
  395.     {
  396.         $this->waiter = $waiter;
  398.         return $this;
  399.     }
  401.     public function isIsDeliverable(): ?bool
  402.     {
  403.         return $this->isDeliverable;
  404.     }
  406.     public function setIsDeliverable(bool $isDeliverable): self
  407.     {
  408.         $this->isDeliverable = $isDeliverable;
  410.         return $this;
  411.     }
  413.     public function getIsClosed(): bool
  414.     {
  415.         return $this->payout >= $this->getAmount();
  416.     }
  418.     public function getRate(): ?Rate
  419.     {
  420.         return $this->rate;
  421.     }
  423.     public function setRate(?Rate $rate): self
  424.     {
  425.         $this->rate = $rate;
  427.         return $this;
  428.     }
  430.     /**
  431.      * @return Collection<int, Shipment>
  432.      */
  433.     public function getShipment(): Collection
  434.     {
  435.         return $this->shipment;
  436.     }
  438.     #[Groups(['order:list'])]
  439.     public function getCurrentShipment(): ?Shipment
  440.     {
  441.         $shipments = $this->getShipment()->map(function (Shipment $shipment) {
  442.             if ($shipment->getCurrentState() == "notShipped" || $shipment->getCurrentState() == Kimia::STATUS_INIT) {
  443.                 return $shipment;
  444.             }
  445.             return null;
  446.         });
  448.         return $shipments->first() ?: null;
  449.     }
  451.     #[Groups(['order:list'])]
  452.     public function getCurrentDestination(): ?string
  453.     {
  454.         return $this->getCurrentShipment()?->getDestination() ?: null;
  455.     }
  457.     public function addShipment(Shipment $shipment): self
  458.     {
  459.         if (!$this->shipment->contains($shipment)) {
  460.             $this->shipment->add($shipment);
  461.             $shipment->setCommand($this);
  462.         }
  464.         return $this;
  465.     }
  467.     public function removeShipment(Shipment $shipment): self
  468.     {
  469.         if ($this->shipment->removeElement($shipment)) {
  470.             // set the owning side to null (unless already changed)
  471.             if ($shipment->getCommand() === $this) {
  472.                 $shipment->setCommand(null);
  473.             }
  474.         }
  476.         return $this;
  477.     }
  479.     public function getEstablishment(): ?Establishment
  480.     {
  481.         return $this->establishment;
  482.     }
  484.     public function setEstablishment(?Establishment $establishment): self
  485.     {
  486.         $this->establishment = $establishment;
  488.         return $this;
  489.     }
  491.     public function isIsProforma(): ?bool
  492.     {
  493.         return $this->isProforma;
  494.     }
  496.     public function setIsProforma(bool $isProforma): static
  497.     {
  498.         $this->isProforma = $isProforma;
  500.         return $this;
  501.     }
  503.     public function getTransaction(): ?Transaction
  504.     {
  505.         return $this->transaction;
  506.     }
  508.     public function setTransaction(?Transaction $transaction): static
  509.     {
  510.         // unset the owning side of the relation if necessary
  511.         if ($transaction === null && $this->transaction !== null) {
  512.             $this->transaction->setOrderCommand(null);
  513.         }
  515.         // set the owning side of the relation if necessary
  516.         if ($transaction !== null && $transaction->getOrderCommand() !== $this) {
  517.             $transaction->setOrderCommand($this);
  518.         }
  520.         $this->transaction = $transaction;
  522.         return $this;
  523.     }
  525.     public function __toString(): string
  526.     {
  527.         return $this->reference;
  528.     }
  530.     /**
  531.      * @return Collection<int, Client>
  532.      */
  533.     public function getClients(): Collection
  534.     {
  535.         return $this->clients;
  536.     }
  538.     public function addClient(Client $client): static
  539.     {
  540.         if (!$this->clients->contains($client)) {
  541.             $this->clients->add($client);
  542.         }
  544.         return $this;
  545.     }
  547.     public function removeClient(Client $client): static
  548.     {
  549.         $this->clients->removeElement($client);
  551.         return $this;
  552.     }
  554.     public function getClientPrincipalI(): ?int
  555.     {
  556.         return $this->clientPrincipalI;
  557.     }
  558.     public function getClientPrincipalInt(): ?int
  559.     {
  560.         return $this->clientPrincipalI - 1;
  561.     }
  563.     public function setClientPrincipalI(int $clientPrincipalI): static
  564.     {
  565.         $this->clientPrincipalI = $clientPrincipalI;
  567.         return $this;
  568.     }
  569. }