src/Entity/Donation.php line 15

1. <?php
3. namespace App\Entity;
5. use App\Entity\Enum\DonationStatus;
6. use App\Entity\Enum\TransactionStatus;
7. use App\Entity\Traits\Identifiable;
8. use App\Entity\Traits\Timestampable;
9. use App\Repository\DonationRepository;
10. use Doctrine\Common\Collections\ArrayCollection;
11. use Doctrine\Common\Collections\Collection;
12. use Doctrine\ORM\Mapping as ORM;
14. #[ORM\Entity(repositoryClass: DonationRepository::class)]
15. class Donation
16. {
17.     use Identifiable;
18.     use Timestampable;
20.     #[ORM\ManyToOne(inversedBy: 'donations')]
21.     private ?Person $person = null;
23.     #[ORM\ManyToOne(inversedBy: 'donations')]
24.     private ?LegalPerson $legalPerson = null;
26.     #[ORM\Column]
27.     private ?float $amount = 0;
29.     #[ORM\Column]
30.     private ?float $amountPayed = 0;
32.     #[ORM\ManyToOne(inversedBy: 'donations')]
33.     private ?Section $section = null;
35.     #[ORM\ManyToOne(inversedBy: 'donations')]
36.     private ?Project $project = null;
38.     #[ORM\OneToMany(mappedBy: 'donation', targetEntity: BenefactorTransaction::class, cascade: ['persist', 'remove'])]
39.     private Collection $transactions;
41.     #[ORM\Column(type: 'string', length: 20, enumType: DonationStatus::class)]
42.     private ?DonationStatus $status = DonationStatus::Prospect;
44.     public function __construct()
45.     {
46.         $this->transactions = new ArrayCollection();
47.     }
49.     public function getPerson(): ?Person
50.     {
51.         return $this->person;
52.     }
54.     public function setPerson(?Person $person): self
55.     {
56.         $this->person = $person;
58.         return $this;
59.     }
61.     public function getLegalPerson(): ?LegalPerson
62.     {
63.         return $this->legalPerson;
64.     }
66.     public function setLegalPerson(?LegalPerson $legalPerson): self
67.     {
68.         $this->legalPerson = $legalPerson;
70.         return $this;
71.     }
73.     public function getAmount(): ?float
74.     {
75.         return $this->amount;
76.     }
78.     public function setAmount(float $amount): self
79.     {
80.         $this->amount = $amount;
82.         return $this;
83.     }
85.     public function getAmountPayed(): ?float
86.     {
87.         return $this->amountPayed;
88.     }
90.     public function setAmountPayed(float $amountPayed): self
91.     {
92.         $this->amountPayed = $amountPayed;
94.         return $this;
95.     }
97.     public function getRemainingAmount(): float
98.     {
99.         $amount = $this->getAmount();
100.         $statuses = [TransactionStatus::Waiting, TransactionStatus::Successful];
101.         foreach ($this->getTransactions(statuses: $statuses) as $transaction) {
102.             if ($transaction->getStatus() === TransactionStatus::Successful) {
103.                 $amount -= $transaction->getAmountPayed();
104.             }
105.         }
107.         return $amount;
108.     }
110.     public function getSection(): ?Section
111.     {
112.         return $this->section;
113.     }
115.     public function setSection(?Section $section): self
116.     {
117.         $this->section = $section;
119.         return $this;
120.     }
122.     public function getProject(): ?Project
123.     {
124.         return $this->project;
125.     }
127.     public function setProject(?Project $project): self
128.     {
129.         $this->project = $project;
131.         return $this;
132.     }
134.     /**
135.      * @return Collection<int, BenefactorTransaction>
136.      */
137.     public function getTransactions(?string $type = null, array|TransactionStatus $statuses = null): Collection
138.     {
139.         $transactions = $this->transactions;
140.         if ($type) {
141.             $transactions = $transactions->filter(fn(BenefactorTransaction $t) => ($t instanceof $type));
142.         }
143.         if ($statuses) {
144.             if (!is_array($statuses)) {
145.                 $statuses = [$statuses];
146.             }
147.             $transactions = $transactions->filter(
148.                 fn(BenefactorTransaction $t) => (in_array($t->getStatus(), $statuses, true))
149.             );
150.         }
152.         return $transactions;
153.     }
155.     public function addTransaction(BenefactorTransaction $transaction): self
156.     {
157.         if (!$this->transactions->contains($transaction)) {
158.             $this->transactions->add($transaction);
159.             $transaction->setDonation($this);
160.         }
162.         return $this;
163.     }
165.     public function removeTransaction(BenefactorTransaction $transaction): self
166.     {
167.         if ($this->transactions->removeElement($transaction)) {
168.             // set the owning side to null (unless already changed)
169.             if ($transaction->getDonation() === $this) {
170.                 $transaction->setDonation(null);
171.             }
172.         }
174.         return $this;
175.     }
177.     public function hasSuccessfulTransaction(?array $types = []): bool
178.     {
179.         $transactions = $this->getTransactions()
180.             ->filter(fn(BenefactorTransaction $t) => $t->getStatus() === TransactionStatus::Successful);
182.         if (count($types) > 0) {
183.             $transactions = $transactions->filter(fn(BenefactorTransaction $t) => in_array(get_class($t), $types, true)
184.             );
185.         }
187.         return $transactions->count() > 0;
188.     }
190.     public function getStatus(): ?DonationStatus
191.     {
192.         return $this->status;
193.     }
195.     public function setStatus(DonationStatus $status): self
196.     {
197.         $this->status = $status;
199.         return $this;
200.     }
202.     public function guessPaymentType(): ?string
203.     {
204.         $foundTransaction = null;
206.         foreach ($this->getTransactions() as $transaction) {
207.             if (null === $foundTransaction || $transaction->getStatus() === TransactionStatus::Successful) {
208.                 $foundTransaction = $transaction;
209.             }
210.         }
212.         if ($foundTransaction) {
213.             $type = array_flip(BenefactorTransaction::TYPE_CLASSES)[$foundTransaction::class];
215.             return BenefactorTransaction::TYPE_NAMES[$type];
216.         }
218.         return null;
219.     }
220. }