src/Entity/SalesCase.php line 26

1. <?php
3. namespace App\Entity;
5. use App\Exception\CurrencyException;
6. use App\Exception\InvalidArgumentException;
7. use App\Exception\NoOrderConfirmationException;
8. use App\Model\Currency;
9. use DateTime;
10. use Doctrine\Common\Collections\ArrayCollection;
11. use Doctrine\Common\Collections\Collection;
12. use Doctrine\ORM\Mapping as ORM;
13. use Symfony\Component\Validator\Constraints as Assert;
14. use Symfony\Component\Validator\Context\ExecutionContextInterface;
16. /**
17.  * @ORM\Entity(
18.  *     repositoryClass="App\Repository\SalesCaseRepository"
19.  * )
20.  * @ORM\Table(
21.  *     name="sales_case",
22.  *     options={"collate"="utf8_swedish_ci"}
23.  * )
24.  * @ORM\HasLifecycleCallbacks
25.  */
26. class SalesCase implements EntityInterface
27. {
28.     const NUMBER_PREFIX = 'C';
30.     const TYPE_OFFER              = 'offer';
31.     const TYPE_ORDER_CONFIRMATION = 'order_confirmation';
32.     const TYPE_PURCHASE_ORDER     = 'purchase_order';
34.     /**
35.      * @ORM\Id
36.      * @ORM\Column(
37.      *     type="integer"
38.      * )
39.      * @ORM\GeneratedValue(
40.      *     strategy="AUTO"
41.      * )
42.      *
43.      * @var int|null
44.      */
45.     protected ?int $id = null;
47.     /**
48.      * @ORM\OneToMany(
49.      *     targetEntity="SalesCaseAttachment",
50.      *     mappedBy="salesCase",
51.      *     cascade={"persist","remove"},
52.      *     orphanRemoval=true
53.      * )
54.      * @ORM\OrderBy({"created" = "DESC"})
55.      *
56.      * @var Collection<SalesCaseAttachment>
57.      */
58.     protected Collection $attachments;
60.     /**
61.      * @ORM\ManyToOne(
62.      *     targetEntity="Company",
63.      *     inversedBy="salesCases"
64.      * )
65.      * @ORM\JoinColumn(
66.      *     name="company_id",
67.      *     referencedColumnName="id"
68.      * )
69.      * @Assert\NotNull
70.      *
71.      * NOTE! There are sales cases in the database with no company set. For this null values need to be supported
72.      * for already persisted sales cases. Remove in future.
73.      *
74.      * @var Company|null
75.      */
76.     protected ?Company $company = null;
78.     /**
79.      * @ORM\Column(
80.      *     type="string",
81.      *     length=3
82.      * )
83.      * @Assert\Choice(
84.      *     callback={"\App\Model\Currency", "getCodeChoices"}
85.      * )
86.      *
87.      * @var string
88.      */
89.     protected string $currency = Currency::DEFAULT_CURRENCY;
91.     /**
92.      * This is used internally for checking if the value of currency is being changed and validation.
93.      *
94.      * @var string
95.      */
96.     protected $currencyOriginal;
98.     /**
99.      * @ORM\Column(
100.      *     type="string",
101.      *     length=2000,
102.      *     nullable=true
103.      * )
104.      *
105.      * @var string|null
106.      */
107.     protected ?string $description = null;
109.     /**
110.      * @ORM\OneToMany(
111.      *     targetEntity="AbstractInvoice",
112.      *     mappedBy="salesCase",
113.      *     cascade={"persist","remove"}
114.      * )
115.      *
116.      * @var Collection<AbstractInvoice>
117.      */
118.     protected Collection $invoices;
120.     /**
121.      * @ORM\OneToMany(
122.      *     targetEntity="Notification",
123.      *     mappedBy="salesCase",
124.      *     cascade={"persist","remove"},
125.      *     orphanRemoval=true
126.      * )
127.      * @ORM\OrderBy({"time" = "ASC"})
128.      * @Assert\Valid
129.      *
130.      * @var Collection<Notification>
131.      */
132.     protected Collection $notifications;
134.     /**
135.      * @ORM\OneToOne(
136.      *     targetEntity="Offer",
137.      *     mappedBy="salesCase",
138.      *     cascade={"persist","remove"},
139.      *     fetch="EXTRA_LAZY"
140.      * )
141.      *
142.      * @var Offer|null
143.      */
144.     protected ?Offer $offer = null;
146.     /**
147.      * @ORM\Column(
148.      *     type="datetime"
149.      * )
150.      *
151.      * @var DateTime
152.      */
153.     protected DateTime $opened;
155.     /**
156.      * @ORM\OneToOne(
157.      *     targetEntity="OrderConfirmation",
158.      *     mappedBy="salesCase",
159.      *     cascade={"persist","remove"}
160.      * )
161.      *
162.      * @var OrderConfirmation|null
163.      */
164.     protected ?OrderConfirmation $orderConfirmation = null;
166.     /**
167.      * @ORM\OneToMany(
168.      *     targetEntity="PackingList",
169.      *     mappedBy="salesCase",
170.      *     cascade={"persist","remove"}
171.      * )
172.      *
173.      * @var Collection<PackingList>
174.      */
175.     protected Collection $packingLists;
177.     /**
178.      * @ORM\OneToMany(
179.      *     targetEntity="PurchaseOrder",
180.      *     mappedBy="salesCase",
181.      *     cascade={"persist","remove"}
182.      * )
183.      *
184.      * @var Collection<PurchaseOrder>
185.      */
186.     protected Collection $purchaseOrders;
188.     /**
189.      * @ORM\Column(
190.      *     type="string",
191.      *     length=20
192.      * )
193.      * @Assert\Choice(
194.      *     callback="getTypeChoices"
195.      * )
196.      *
197.      * @var string
198.      */
199.     protected string $type = self::TYPE_OFFER;
201.     /**
202.      * @param Company $company
203.      * @param string $type
204.      */
205.     public function __construct(Company $company, string $type = self::TYPE_OFFER)
206.     {
207.         $this->setCompany($company);
208.         $this->setType($type);
209.         $this->attachments = new ArrayCollection();
210.         $this->invoices = new ArrayCollection();
211.         $this->notifications = new ArrayCollection();
212.         $this->packingLists = new ArrayCollection();
213.         $this->purchaseOrders = new ArrayCollection();
214.         $this->opened = new DateTime();
215.     }
217.     /**
218.      * @param SalesCaseAttachment $attachment
219.      *
220.      * @throws InvalidArgumentException
221.      */
222.     public function addAttachment(SalesCaseAttachment $attachment): void
223.     {
224.         if ($attachment->getSalesCase() !== $this) {
225.             throw new InvalidArgumentException('Invalid sales case for attachment');
226.         }
227.         $this->attachments->add($attachment);
228.     }
230.     /**
231.      * @param Notification $notification
232.      */
233.     public function addNotification(Notification $notification): void
234.     {
235.         $notification->setSalesCase($this);
236.         $this->notifications->add($notification);
237.     }
239.     /**
240.      * @return SalesCaseAttachment[]|Collection
241.      */
242.     public function getAttachments()
243.     {
244.         return $this->attachments;
245.     }
247.     /**
248.      * @return BankAccount|null
249.      */
250.     public function getBankAccount(): ?BankAccount
251.     {
252.         return $this->company->getBankAccount();
253.     }
255.     /**
256.      * @return Company|null
257.      */
258.     public function getCompany(): ?Company
259.     {
260.         return $this->company;
261.     }
263.     /**
264.      * @param bool $defaultCurrency
265.      *
266.      * @return int
267.      *
268.      * @throws CurrencyException
269.      */
270.     public function getCostOfSales(bool $defaultCurrency = false): int
271.     {
272.         $total = 0;
273.         foreach ($this->getPurchaseOrders() as $purchaseOrder) {
274.             if ($purchaseOrder->isSent()) {
275.                 $total += $purchaseOrder->getValueNet($defaultCurrency);
276.             }
277.         }
279.         return $total;
280.     }
282.     /**
283.      * @return string
284.      */
285.     public function getCurrency(): string
286.     {
287.         return $this->currency;
288.     }
290.     /**
291.      * @return null|string
292.      */
293.     public function getDescription(): ?string
294.     {
295.         return $this->description;
296.     }
298.     /**
299.      * @return float
300.      *
301.      * @throws NoOrderConfirmationException
302.      * @throws CurrencyException
303.      */
304.     public function getGrossMargin(): float
305.     {
306.         if (null === $orderConfirmation = $this->getOrderConfirmation()) {
307.             throw new NoOrderConfirmationException('The sales case does not have an order confirmation.');
308.         }
309.         $sales = $orderConfirmation->getValueNet(false);
310.         if ($sales == 0) {
311.             return 0.0;
312.         }
314.         return ($sales - $this->getCostOfSales(false)) / $sales;
315.     }
317.     /**
318.      * @return int|null
319.      */
320.     public function getId(): ?int
321.     {
322.         return $this->id;
323.     }
325.     /**
326.      * @return Collection<AbstractInvoice>
327.      */
328.     public function getInvoices(): Collection
329.     {
330.         return $this->invoices;
331.     }
333.     /**
334.      * @param bool $excludeDrafts
335.      *
336.      * @return Collection<CreditInvoice>
337.      */
338.     public function getInvoicesOfTypeCreditInvoice(bool $excludeDrafts = false): Collection
339.     {
340.         return $this->invoices->filter(
341.             function ($invoice) use ($excludeDrafts) {
342.                 /* @var AbstractInvoice $invoice */
343.                 if ($excludeDrafts && $invoice->isDraft()) {
344.                     return false;
345.                 }
347.                 return $invoice instanceof CreditInvoice;
348.             }
349.         );
350.     }
352.     /**
353.      * @param bool $excludeDrafts
354.      *
355.      * @return Collection<DownPaymentInvoice>
356.      */
357.     public function getInvoicesOfTypeDownPaymentInvoice(bool $excludeDrafts = false): Collection
358.     {
359.         return $this->invoices->filter(
360.             function ($invoice) use ($excludeDrafts) {
361.                 /* @var AbstractInvoice $invoice */
362.                 if ($excludeDrafts && $invoice->isDraft()) {
363.                     return false;
364.                 }
366.                 return $invoice instanceof DownPaymentInvoice;
367.             }
368.         );
369.     }
371.     /**
372.      * @param bool $excludeDrafts
373.      *
374.      * @return Collection<Invoice>
375.      */
376.     public function getInvoicesOfTypeInvoice(bool $excludeDrafts = false): Collection
377.     {
378.         return $this->invoices->filter(
379.             function ($invoice) use ($excludeDrafts) {
380.                 /* @var AbstractInvoice $invoice */
381.                 if ($excludeDrafts && $invoice->isDraft()) {
382.                     return false;
383.                 }
385.                 return $invoice instanceof Invoice;
386.             }
387.         );
388.     }
390.     /**
391.      * @param bool $excludeDrafts
392.      *
393.      * @return Collection<ProformaInvoice>
394.      */
395.     public function getInvoicesOfTypeProformaInvoice(bool $excludeDrafts = false): Collection
396.     {
397.         return $this->invoices->filter(
398.             function ($invoice) use ($excludeDrafts) {
399.                 /* @var AbstractInvoice $invoice */
400.                 if ($excludeDrafts && $invoice->isDraft()) {
401.                     return false;
402.                 }
404.                 return $invoice instanceof ProformaInvoice;
405.             }
406.         );
407.     }
409.     /**
410.      * @return CreditInvoice
411.      */
412.     public function getNewCreditInvoice(): CreditInvoice
413.     {
414.         return new CreditInvoice($this);
415.     }
417.     /**
418.      * @return DownPaymentInvoice
419.      */
420.     public function getNewDownPaymentInvoice(): DownPaymentInvoice
421.     {
422.         return new DownPaymentInvoice($this);
423.     }
425.     /**
426.      * @return Invoice
427.      */
428.     public function getNewInvoice(): Invoice
429.     {
430.         return new Invoice($this);
431.     }
433.     /**
434.      * @return ProformaInvoice
435.      */
436.     public function getNewProformaInvoice(): ProformaInvoice
437.     {
438.         return new ProformaInvoice($this);
439.     }
441.     /**
442.      * @return PackingList
443.      */
444.     public function getNewPackingList(): PackingList
445.     {
446.         return new PackingList($this);
447.     }
449.     /**
450.      * @return PurchaseOrder
451.      */
452.     public function getNewPurchaseOrder(): PurchaseOrder
453.     {
454.         return new PurchaseOrder($this, new Supplier(''));
455.     }
457.     /**
458.      * @return Notification|null
459.      */
460.     public function getNextNotification(): ?Notification
461.     {
462.         foreach ($this->getNotifications() as $notification) {
463.             if ($notification->getTime()->getTimestamp() > time()) {
464.                 return $notification;
465.             }
466.         }
468.         return null;
469.     }
471.     /**
472.      * @return Collection<Notification>
473.      */
474.     public function getNotifications(): Collection
475.     {
476.         return $this->notifications;
477.     }
479.     /**
480.      * @return string
481.      */
482.     public function getNumber(): string
483.     {
484.         return self::NUMBER_PREFIX . str_pad($this->id, 6, '0', STR_PAD_LEFT);
485.     }
487.     /**
488.      * @return Offer|null
489.      */
490.     public function getOffer(): ?Offer
491.     {
492.         return $this->offer;
493.     }
495.     /**
496.      * @return DateTime
497.      */
498.     public function getOpened(): DateTime
499.     {
500.         return $this->opened;
501.     }
503.     /**
504.      * @return OrderConfirmation|null
505.      */
506.     public function getOrderConfirmation(): ?OrderConfirmation
507.     {
508.         return $this->orderConfirmation;
509.     }
511.     /**
512.      * @return Collection<PackingList>
513.      */
514.     public function getPackingLists(): Collection
515.     {
516.         return $this->packingLists;
517.     }
519.     /**
520.      * @return Collection<PurchaseOrder>
521.      */
522.     public function getPurchaseOrders(): Collection
523.     {
524.         return $this->purchaseOrders;
525.     }
527.     /**
528.      * @param bool $defaultCurrency
529.      *
530.      * @return int
531.      *
532.      * @throws NoOrderConfirmationException
533.      */
534.     public function getRemainingInvoiceValue(bool $defaultCurrency = false): int
535.     {
536.         if ($this->orderConfirmation === null) {
537.             throw new NoOrderConfirmationException('The sales case has no order confirmation');
538.         }
540.         $totalInvoiced = 0;
541.         foreach ($this->getInvoicesOfTypeInvoice() as $invoice) {
542.             if (!$invoice->isDraft()) {
543.                 $totalInvoiced += $invoice->getValueNet($defaultCurrency);
544.             }
545.         }
546.         foreach ($this->getInvoicesOfTypeCreditInvoice() as $invoice) {
547.             if (!$invoice->isDraft()) {
548.                 $totalInvoiced -= $invoice->getValueNet($defaultCurrency);
549.             }
550.         }
552.         return $this->orderConfirmation->getValueNet($defaultCurrency) - $totalInvoiced;
553.     }
555.     /**
556.      * @return string
557.      */
558.     public function getStatus(): string
559.     {
560.         if ($this->type == self::TYPE_OFFER) {
561.             if ($this->offer === null) {
562.                 return 'draft';
563.             } elseif ($this->orderConfirmation === null) {
564.                 return 'offer_' . $this->offer->getStatus();
565.             } else {
566.                 return 'oc_' . $this->orderConfirmation->getStatus();
567.             }
568.         } elseif ($this->type == self::TYPE_ORDER_CONFIRMATION) {
569.             if ($this->orderConfirmation === null) {
570.                 return 'draft';
571.             } else {
572.                 return 'oc_' . $this->orderConfirmation->getStatus();
573.             }
574.         } elseif ($this->type == self::TYPE_PURCHASE_ORDER) {
575.             if (count($this->purchaseOrders) == 0) {
576.                 return 'draft';
577.             } else {
578.                 return 'po';
579.             }
580.         }
582.         return '';
583.     }
585.     /**
586.      * @return string[]
587.      */
588.     public static function getStatusChoices(): array
589.     {
590.         return [
591.             'draft',
592.             'offer_draft',
593.             'offer_sent',
594.             'offer_rejected',
595.             'oc_draft',
596.             'oc_not_confirmed',
597.             'oc_preliminary_confirmed',
598.             'oc_confirmed',
599.             'oc_partially_delivered',
600.             'oc_equipment_delivered',
601.             'oc_delivered',
602.             'oc_completed',
603.             'oc_risk_order',
604.             'oc_rejected',
605.             'po',
606.         ];
607.     }
609.     /**
610.      * @return string
611.      */
612.     public function getType(): string
613.     {
614.         return $this->type;
615.     }
617.     /**
618.      * @return string[]
619.      */
620.     public static function getTypeChoices(): array
621.     {
622.         return [
623.             self::TYPE_OFFER,
624.             self::TYPE_ORDER_CONFIRMATION,
625.             self::TYPE_PURCHASE_ORDER,
626.         ];
627.     }
629.     /**
630.      * @return bool
631.      */
632.     public function isCompleted(): bool
633.     {
634.         if ($this->type == self::TYPE_PURCHASE_ORDER) {
635.             /**
636.              * A PO only case is considered completed if it has POs and none of them have Draft status
637.              */
638.             $hasDrafts = false;
639.             $purchaseOrders = $this->getPurchaseOrders();
640.             foreach ($purchaseOrders as $purchaseOrder) {
641.                 if ($purchaseOrder->isDraft()) {
642.                     $hasDrafts = true;
643.                     break;
644.                 }
645.             }
646.             if (count($purchaseOrders) > 0 && !$hasDrafts) {
647.                 return true;
648.             }
649.         } elseif (null !== $this->orderConfirmation) {
650.             if ($this->orderConfirmation->isCompleted()) {
651.                 return true;
652.             }
653.             if (!$this->orderConfirmation->isRejected() && !$this->orderConfirmation->isDraft()) {
654.                 if (count($this->orderConfirmation->getSalesItems()) > 0 && count($this->orderConfirmation->getUninvoicedSalesItems(false)) == 0) {
655.                     return true;
656.                 }
657.             }
658.         }
660.         return false;
661.     }
663.     /**
664.      * @return bool
665.      */
666.     public function isDraft(): bool
667.     {
668.         return $this->getStatus() == 'draft';
669.     }
671.     /**
672.      * @ORM\PostLoad
673.      */
674.     public function postLoad()
675.     {
676.         $this->currencyOriginal = $this->currency;
677.     }
679.     public function removeAttachment(SalesCaseAttachment $attachment): void
680.     {
681.         $this->attachments->removeElement($attachment);
682.     }
684.     /**
685.      * @param Notification $notification
686.      */
687.     public function removeNotification(Notification $notification): void
688.     {
689.         $this->notifications->removeElement($notification);
690.     }
692.     /**
693.      * @param Company $company
694.      */
695.     public function setCompany(Company $company): void
696.     {
697.         $this->company = $company;
698.         $this->currency = $company->getCurrency();
699.     }
701.     /**
702.      * @param string $currency
703.      */
704.     public function setCurrency(string $currency): void
705.     {
706.         $this->currency = $currency;
707.     }
709.     /**
710.      * @param string|null $description
711.      */
712.     public function setDescription(?string $description): void
713.     {
714.         $this->description = $description;
715.     }
717.     /**
718.      * @param Offer $offer
719.      */
720.     public function setOffer(Offer $offer): void
721.     {
722.         $this->offer = $offer;
723.     }
725.     /**
726.      * @param DateTime $opened
727.      */
728.     public function setOpened(DateTime $opened)
729.     {
730.         $this->opened = $opened;
731.     }
733.     /**
734.      * @param OrderConfirmation $orderConfirmation
735.      */
736.     public function setOrderConfirmation(OrderConfirmation $orderConfirmation)
737.     {
738.         $this->orderConfirmation = $orderConfirmation;
739.     }
741.     /**
742.      * @param string $type
743.      */
744.     public function setType(string $type): void
745.     {
746.         $this->type = $type;
747.     }
749.     /**
750.      * @Assert\Callback
751.      *
752.      * @param ExecutionContextInterface $context
753.      */
754.     public function validate(ExecutionContextInterface $context): void
755.     {
756.         if ($this->company->getCurrency() != $this->currency) {
757.             $context
758.                 ->buildViolation(
759.                     'validation.currency.mismatch',
760.                     [
761.                         '%company_currency%' => $this->company->getCurrency(),
762.                         '%currency%'         => $this->currency,
763.                     ]
764.                 )
765.                 ->setTranslationDomain('SalesCase')
766.                 ->atPath('company')
767.                 ->addViolation();
768.             $context
769.                 ->buildViolation(
770.                     'validation.currency.mismatch',
771.                     [
772.                         '%company_currency%' => $this->company->getCurrency(),
773.                         '%currency%'         => $this->currency,
774.                     ]
775.                 )
776.                 ->setTranslationDomain('SalesCase')
777.                 ->atPath('currency')
778.                 ->addViolation();
779.         }
780.         // Check if currency id being changed
781.         // The currency can only be changed if the sales case does not yet have an Offer or and OC document
782.         if ($this->currencyOriginal != $this->currency) {
783.             if ($this->offer !== null || $this->orderConfirmation !== null) {
784.                 $context
785.                     ->buildViolation('validation.currency.readonly')
786.                     ->setTranslationDomain('SalesCase')
787.                     ->atPath('currency')
788.                     ->addViolation();
789.             }
790.         }
791.     }
792. }