src/Entity/Order.php line 15

1. <?php
3. namespace App\Entity;
5. use App\Entity\Enum\TransactionStatus;
6. use App\Entity\Traits\Identifiable;
7. use App\Entity\Traits\Timestampable;
8. use App\Repository\OrderRepository;
9. use Doctrine\Common\Collections\ArrayCollection;
10. use Doctrine\Common\Collections\Collection;
11. use Doctrine\ORM\Mapping as ORM;
13. #[ORM\Entity(repositoryClass: OrderRepository::class)]
14. #[ORM\Table(name: '`order`')]
15. class Order
16. {
17.     use Identifiable;
18.     use Timestampable;
20.     #[ORM\Column(type: 'float')]
21.     private $amount = 0;
23.     #[ORM\Column(type: 'string', length: 10, nullable: true)]
24.     private $type;
26.     #[ORM\OneToOne(inversedBy: 'order', targetEntity: Registration::class, cascade: ['persist', 'remove'])]
27.     private $registration;
29.     #[ORM\OneToMany(mappedBy: 'order', targetEntity: Cart::class, cascade: ['persist', 'remove'])]
30.     private $carts;
32.     #[ORM\OneToMany(mappedBy: 'order', targetEntity: Transaction::class, cascade: ['persist', 'remove'])]
33.     private $transactions;
35.     public function __construct()
36.     {
37.         $this->carts = new ArrayCollection();
38.         $this->transactions = new ArrayCollection();
39.         $this->addCart(new Cart());
40.     }
42.     public function getAmount(): ?float
43.     {
44.         return $this->amount;
45.     }
47.     public function getDiscountAmount(?bool $aids = null): float
48.     {
49.         $total = 0;
50.         foreach ($this->getCart()?->getDiscounts($aids) ?? [] as $cartItemDiscount) {
51.             if ($discount = $cartItemDiscount->getDiscount()) {
52.                 $total += ($discount->getRemainingToPay() * -1);
53.             } else {
54.                 $total += $cartItemDiscount->getPrice();
55.             }
56.         }
58.         return $total * -1;
59.     }
61.     public function getRemainingAmount($includeDiscounts = true): float
62.     {
63.         $amount = $this->getAmount();
64.         $statuses = [TransactionStatus::Waiting, TransactionStatus::Successful];
65.         foreach ($this->getTransactions(statuses: $statuses) as $transaction) {
66.             if ($transaction->getStatus() === TransactionStatus::Successful) {
67.                 $amount -= $transaction->getAmountPayed();
68.             } elseif ($transaction instanceof TransactionCardMulti
69.                 && $transaction->getStatus() === TransactionStatus::Waiting) {
70.                 $amount -= $transaction->getAmount();
71.             }
72.         }
73.         if ($includeDiscounts) {
74.             $amount -= $this->getDiscountAmount(true);
75.         }
77.         return $amount;
78.     }
80.     public function getPayedAmount(): float
81.     {
82.         $amount = 0;
83.         foreach ($this->getTransactions() as $transaction) {
84.             if ($transaction->getStatus() === TransactionStatus::Successful) {
85.                 $amount += $transaction->getAmountPayed();
86.             } elseif ($transaction instanceof TransactionCardMulti &&
87.                 $transaction->getStatus() === TransactionStatus::Waiting &&
88.                 $transaction->getCycle() > 1) {
89.                 $amount += $transaction->getAmount();
90.             }
91.         }
93.         return $amount;
94.     }
96.     public function setAmount(float $amount): self
97.     {
98.         $this->amount = $amount;
100.         return $this;
101.     }
103.     public function getType(): ?string
104.     {
105.         return $this->type;
106.     }
108.     public function setType(?string $type): self
109.     {
110.         $this->type = $type;
112.         return $this;
113.     }
115.     public function getRegistration(): ?Registration
116.     {
117.         return $this->registration;
118.     }
120.     public function setRegistration(?Registration $registration): self
121.     {
122.         $this->registration = $registration;
124.         return $this;
125.     }
127.     /**
128.      * @return Collection<int, Cart>
129.      */
130.     public function getCarts(): Collection
131.     {
132.         return $this->carts;
133.     }
135.     public function addCart(Cart $cart): self
136.     {
137.         if (!$this->carts->contains($cart)) {
138.             $this->carts[] = $cart;
139.             $cart->setOrder($this);
140.         }
142.         return $this;
143.     }
145.     public function removeCart(Cart $cart): self
146.     {
147.         if ($this->carts->removeElement($cart)) {
148.             // set the owning side to null (unless already changed)
149.             if ($cart->getOrder() === $this) {
150.                 $cart->setOrder(null);
151.             }
152.         }
154.         return $this;
155.     }
157.     public function getCart(): ?Cart
158.     {
159.         $cart = $this->carts->first();
161.         return $cart === false ? null : $cart;
162.     }
164.     /**
165.      * @param string|null $type
166.      * @param TransactionStatus|array<int, TransactionStatus>|null $statuses
167.      * @return Collection<int, Transaction>
168.      */
169.     public function getTransactions(?string $type = null, array|TransactionStatus $statuses = null): Collection
170.     {
171.         $transactions = $this->transactions;
172.         if ($type) {
173.             $transactions = $transactions->filter(fn(Transaction $t) => ($t instanceof $type));
174.         }
175.         if ($statuses) {
176.             if (!is_array($statuses)) {
177.                 $statuses = [$statuses];
178.             }
179.             $transactions = $transactions->filter(fn(Transaction $t) => (in_array($t->getStatus(), $statuses, true)));
180.         }
182.         return $transactions;
183.     }
185.     public function addTransaction(Transaction $transaction): self
186.     {
187.         if (!$this->transactions->contains($transaction)) {
188.             $this->transactions[] = $transaction;
189.             $transaction->setOrder($this);
190.         }
192.         return $this;
193.     }
195.     public function removeTransaction(Transaction $transaction): self
196.     {
197.         if ($this->transactions->removeElement($transaction)) {
198.             // set the owning side to null (unless already changed)
199.             if ($transaction->getOrder() === $this) {
200.                 $transaction->setOrder(null);
201.             }
202.         }
204.         return $this;
205.     }
207.     public function getExpectedTransactionType(): ?string
208.     {
209.         foreach ($this->getTransactions() as $transaction) {
210.             if ($transaction->getStatus() === TransactionStatus::Waiting) {
211.                 return get_class($transaction);
212.             }
213.         }
215.         return null;
216.     }
218.     public function hasSuccessfulTransaction(?array $types = []): bool
219.     {
220.         $transactions = $this->getTransactions()
221.             ->filter(fn(Transaction $t) => $t->getStatus() === TransactionStatus::Successful);
223.         if (count($types) > 0) {
224.             $transactions = $transactions->filter(fn(Transaction $t) => in_array(get_class($t), $types, true));
225.         }
227.         return $transactions->count() > 0;
228.     }
229. }