1. <?php
3. namespace App\Entity\CRM;
5. use App\Repository\OrderRepository;
6. use DateTime;
7. use DateTimeInterface;
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. class Order
16. {
17.     #[ORM\Id]
18.     #[ORM\GeneratedValue]
19.     #[ORM\Column]
20.     private ?int $id = null;
22.     #[ORM\ManyToOne(inversedBy: 'orders')]
23.     #[ORM\JoinColumn(nullable: false)]
24.     private ?OrderStatus $orderStatus = null;
26.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
27.     private ?DateTimeInterface $addedDate = null;
29.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
30.     private ?DateTimeInterface $updateDate = null;
32.     #[ORM\ManyToOne(inversedBy: 'orders')]
33.     #[ORM\JoinColumn(nullable: false)]
34.     private ?Shipping $shipping = null;
36.     #[ORM\ManyToOne(inversedBy: 'orders')]
37.     #[ORM\JoinColumn(nullable: true)]
38.     private ?Consultant $consultant = null;
40.     #[ORM\Column(nullable: true)]
41.     private ?int $administrationFee = null;
43.     #[ORM\Column(nullable: true)]
44.     private ?int $ranking = null;
46.     #[ORM\Column(nullable: true)]
47.     private ?string $invoiceNumber = null;
49.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
50.     private ?DateTimeInterface $invoiceIssueDate = null;
52.     #[ORM\Column]
53.     private ?bool $optimaInvoiceAdded = false;
55.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
56.     private ?DateTimeInterface $optimaInvoiceAddedAt = null;
58.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
59.     private ?DateTimeInterface $paymentDate = null;
61.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
62.     private ?DateTimeInterface $dateOfPayment = null;
64.     #[ORM\Column]
65.     private ?bool $ended = false;
67.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
68.     private ?DateTimeInterface $contractExpirationDate = null;
70.     #[ORM\Column]
71.     private ?bool $fixedTerm = false;
73.     #[ORM\Column]
74.     private ?bool $contractEnded = false;
76.     #[ORM\Column(length: 255, nullable: true)]
77.     private ?string $contractNumber = null;
79.     #[ORM\Column]
80.     private ?bool $checked = false;
82.     #[ORM\Column]
83.     private ?bool $firstOrder = false;
85.     #[ORM\ManyToMany(targetEntity: Implementer::class, inversedBy: 'orders')]
86.     private Collection $implementer;
88.     #[ORM\Column(length: 255, nullable: true)]
89.     private ?string $inspector = null;
91.     #[ORM\Column]
92.     private ?bool $implementationCompleted = false;
94.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
95.     private ?DateTimeInterface $implementationCompletedDate = null;
97.     #[ORM\ManyToOne(targetEntity: self::class)]
98.     private ?self $parentOrder = null;
100.     #[ORM\Column]
101.     private ?bool $contractExtended = false;
103.     #[ORM\Column]
104.     private ?bool $firstContract = false;
106.     #[ORM\Column]
107.     private ?bool $contractSigned = false;
109.     #[ORM\Column(length: 255, nullable: true)]
110.     private ?string $token = null;
112.     #[ORM\Column]
113.     private ?bool $automaticallyExtended = false;
115.     #[ORM\Column(length: 255, nullable: true)]
116.     private ?string $tokenOffice = null;
118.     #[ORM\Column(nullable: true)]
119.     private ?int $recommendedNumber = null;
121.     #[ORM\Column(length: 255, nullable: true)]
122.     private ?string $officeInvoice = null;
124.     #[ORM\Column(nullable: true)]
125.     private ?int $commissionPercentage = null;
127.     #[ORM\Column(nullable: true)]
128.     private ?int $activationAmmount = null;
130.     #[ORM\Column]
131.     private ?bool $officeContractEnded = false;
133.     #[ORM\Column(nullable: true)]
134.     private ?int $bhpPackage = null;
136.     #[ORM\Column(length: 255, nullable: true)]
137.     private ?string $tokenBhpRodo = null;
139.     #[ORM\Column(nullable: true)]
140.     private ?int $reward = null;
142.     #[ORM\Column(length: 255, nullable: true)]
143.     private ?string $tokenIod = null;
145.     #[ORM\Column(length: 255, nullable: true)]
146.     private ?string $tokenBdo = null;
148.     #[ORM\Column(length: 255, nullable: true)]
149.     private ?string $tokenBhpStationary = null;
151.     #[ORM\Column]
152.     private ?bool $auditReady = false;
154.     #[ORM\Column]
155.     private ?bool $auditEnded = false;
157.     #[ORM\Column]
158.     private ?bool $contractWithoutCourses = false;
160.     public float $priceTotal = 0;
162.     public float $priceSubtotal = 0;
164.     public array $prices = [];
166.     public string $firstOrderString = '';
168.     #[ORM\OneToMany(mappedBy: 'orderId', targetEntity: OrderHistory::class, orphanRemoval: true)]
169.     private Collection $orderHistories;
171.     #[ORM\ManyToOne(inversedBy: 'orders')]
172.     #[ORM\JoinColumn(nullable: false)]
173.     private ?Customer $customer = null;
175.     #[ORM\ManyToOne(inversedBy: 'orders')]
176.     #[ORM\JoinColumn(nullable: true)]
177.     private ?CustomerAddress $customerAddress = null;
179.     #[ORM\OneToMany(mappedBy: 'orderId', targetEntity: OrderProduct::class, cascade: ['persist'], orphanRemoval: true,)]
180.     private Collection $orderProduct;
182.     #[ORM\ManyToOne(inversedBy: 'orders')]
183.     #[ORM\JoinColumn(nullable: false)]
184.     private ?Branch $branch = null;
186.     #[ORM\OneToOne(inversedBy: 'orderInstance', cascade: ['persist', 'remove'])]
187.     private ?Contract $contract = null;
189.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: Instalments::class, cascade: ['persist', 'remove'])]
190.     private Collection $instalments;
192.     #[ORM\Column]
193.     private ?bool $instalment = false;
195.     #[ORM\OneToOne(inversedBy: 'orderInst', cascade: ['persist', 'remove'])]
196.     private ?ContractIndividual $contractIndividual = null;
198.     #[ORM\Column(nullable: true)]
199.     private ?bool $needContract = null;
201.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: OrderNote::class)]
202.     private Collection $orderNotes;
204.     #[ORM\ManyToOne(inversedBy: 'dividedOrders')]
205.     private ?Consultant $orderDividedConsultant = null;
206.     #[ORM\OneToMany(mappedBy: 'orderId', targetEntity: ImplementerOrderHistory::class)]
207.     private Collection $implementerOrderHistories;
209.     #[ORM\OneToOne(mappedBy: 'orderId', cascade: ['persist', 'remove'])]
210.     private ?ImplementerOrderData $implementerOrderData = null;
212.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: BhpOrderProduct::class)]
213.     private Collection $BhpOrderProducts;
215.     #[ORM\ManyToOne(inversedBy: 'orders')]
216.     private ?Admin $admin = null;
218.     #[ORM\Column]
219.     private bool $doBeforePayment = false;
221.     #[ORM\Column(nullable: true)]
222.     private ?int $oldOrderId = null;
224.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: AccountingOfficeCategory::class)]
225.     private Collection $accountingOfficeCategories;
227.     #[ORM\OneToMany(mappedBy: 'OrderInstance', targetEntity: BhpJournals::class)]
228.     private Collection $bhpJournals;
230.     #[ORM\Column(length: 255, nullable: true)]
231.     private ?string $tokenAml = null;
233.     #[ORM\Column(length: 255, nullable: true)]
234.     private ?string $tokenAmlrodo = null;
236.     #[ORM\ManyToOne(inversedBy: 'orders')]
237.     private ?DebtStatus $debtStatus = null;
239.     #[ORM\Column]
240.     private ?bool $debtCollection = null;
242.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
243.     private ?\DateTimeInterface $debtContactDate = null;
245.     #[ORM\OneToMany(mappedBy: 'orderId', targetEntity: DebtNote::class)]
246.     private Collection $debtNotes;
248.     #[ORM\Column(type: Types::TEXT, nullable: true)]
249.     private ?string $littleNote = null;
251.     #[ORM\OneToOne(mappedBy: 'orderId', cascade: ['persist', 'remove'])]
252.     private ?OrderCustomer $orderCustomer = null;
254.     #[ORM\OneToOne(mappedBy: 'orderId', cascade: ['persist', 'remove'])]
255.     private ?OrderCustomerAddress $orderCustomerAddress = null;
257.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
258.     private ?\DateTimeInterface $contractSignedDate = null;
261.     #[ORM\OneToMany(mappedBy: 'orderId', targetEntity: OrderDivided::class, orphanRemoval: true)]
262.     private Collection $orderDivideds;
264.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: MailHistory::class)]
265.     private Collection $mailHistories;
267.     #[ORM\Column]
268.     private ?bool $haveInstalments = false;
270.     #[ORM\ManyToOne(inversedBy: 'extensionOrders')]
271.     private ?OrderNote $orderNoteForExtension = null;
273.     #[ORM\Column]
274.     private bool $implementationCompletedWithoutAudit = false;
276.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
277.     private ?\DateTimeInterface $debtStatusChangeDate = null;
279.     #[ORM\ManyToMany(targetEntity: Consultant::class, inversedBy: 'ordersToNotes')]
280.     private Collection $consultantForNotes;
282.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: Task::class)]
283.     private Collection $tasks;
285.     #[ORM\OneToMany(mappedBy: 'orderId', targetEntity: SmsHistory::class)]
286.     private Collection $smsHistories;
288.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
289.     private ?\DateTimeInterface $noticeDate = null;
291.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: SurveyResponse::class)]
292.     private Collection $surveyResponses;
294.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: ZoomList::class)]
295.     private Collection $zoomLists;
297.     #[ORM\Column(length: 255, nullable: true)]
298.     private ?string $tokenLicencyjnaWebAml = null;
300.     #[ORM\Column(length: 255, nullable: true)]
301.     private ?string $tokenLicencyjnaWebAmlPartnerska = null;
303.     #[ORM\Column(length: 255, nullable: true)]
304.     private ?string $tokenLicencyjnaWebAmlNieruchomosci = null;
306.     #[ORM\Column(length: 255, nullable: true)]
307.     private ?string $aneksToken = null;
309.     #[ORM\Column(length: 255, nullable: true)]
310.     private ?string $tokenKontrolaZarzadczaJst = null;
311.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
312.     private ?\DateTimeInterface $dateForPoints = null;
314.     #[ORM\Column]
315.     private ?bool $pointsAdded = null;
317.     #[ORM\Column]
318.     private ?bool $forCountingSprawozdaniaOther = null;
320.     #[ORM\Column]
321.     private ?bool $annex = null;
323.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
324.     private ?\DateTimeInterface $terminationDate = null;
326.     #[ORM\Column]
327.     private ?bool $effectivelyTerminated = null;
329.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
330.     private ?\DateTimeInterface $contractStartDate = null;
332.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: OrderReminder::class, orphanRemoval: true)]
333.     private Collection $orderReminders;
335.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: OrderLicence::class)]
336.     private Collection $orderLicense;
338.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'aneksOrders')]
339.     private ?self $aneksOrder = null;
341.     #[ORM\OneToMany(mappedBy: 'aneksOrder', targetEntity: self::class)]
342.     private Collection $aneksOrders;
344.     public function __construct()
345.     {
346.         $this->addedDate = new DateTime();
347.         $this->updateDate = new DateTime();
348.         $this->implementer = new ArrayCollection();
349.         $this->orderHistories = new ArrayCollection();
350.         $this->orderProduct = new ArrayCollection();
351.         $this->instalments = new ArrayCollection();
352.         $this->orderNotes = new ArrayCollection();
353.         $this->implementerOrderHistories = new ArrayCollection();
354.         $this->BhpOrderProducts = new ArrayCollection();
355.         $this->accountingOfficeCategories = new ArrayCollection();
356.         $this->bhpJournals = new ArrayCollection();
357.         $this->debtNotes = new ArrayCollection();
358.         $this->orderDivideds = new ArrayCollection();
359.         $this->mailHistories = new ArrayCollection();
360.         $this->orderNoteForExtension = NULL;
361.         $this->consultantForNotes = new ArrayCollection();
362.         $this->tasks = new ArrayCollection();
363.         $this->smsHistories = new ArrayCollection();
364.         $this->noticeDate = NULL;
365.         $this->surveyResponses = new ArrayCollection();
366.         $this->zoomLists = new ArrayCollection();
367.         $this->pointsAdded = false;
368.         $this->dateForPoints = NULL;
369.         $this->forCountingSprawozdaniaOther = false;
370.         $this->annex = false;
371.         $this->terminationDate = NULL;
372.         $this->effectivelyTerminated = false;
373.         $this->orderLicense = new ArrayCollection();
374.         $this->aneksOrders = new ArrayCollection();
375.     }
377.     public function __toString(): string
378.     {
379.         return $this->getId();
380.     }
382.     public function getId(): ?int
383.     {
384.         return $this->id;
385.     }
387.     public function getOrderSubTotal(): float
388.     {
389.         $products = $this->getOrderProduct();
390.         $sum = 0;
391.         foreach ($this->getOrderProduct() as $product) {
392.             $sum = $sum+$product->getPriceSubtotal();
393.         }
394.         return $sum;
395.     }
397.     public function getOrderTotal(): float
398.     {
399.         $products = $this->getOrderProduct();
400.         $sum = 0;
401.         foreach ($this->getOrderProduct() as $product) {
402.             $sum = +$product->getPriceTotal();
403.         }
404.         return $sum;
405.     }
407.     public function getOrderStatus(): ?OrderStatus
408.     {
409.         return $this->orderStatus;
410.     }
412.     public function setOrderStatus(?OrderStatus $orderStatus): self
413.     {
414.         $this->orderStatus = $orderStatus;
416.         return $this;
417.     }
419.     public function getAddedDate(): DateTimeInterface
420.     {
421.         return $this->addedDate;
422.     }
425.     public function getUpdateDate(): ?DateTimeInterface
426.     {
427.         return $this->updateDate;
428.     }
430.     public function setUpdateDate(?DateTimeInterface $updateDate): self
431.     {
432.         $this->updateDate = $updateDate;
434.         return $this;
435.     }
437.     public function getShipping(): ?Shipping
438.     {
439.         return $this->shipping;
440.     }
442.     public function setShipping(?Shipping $shipping): self
443.     {
444.         $this->shipping = $shipping;
446.         return $this;
447.     }
449.     public function getConsultant(): ?Consultant
450.     {
451.         return $this->consultant;
452.     }
454.     public function setConsultant(?Consultant $consultant): self
455.     {
456.         $this->consultant = $consultant;
458.         return $this;
459.     }
461.     public function getAdministrationFee(): ?int
462.     {
463.         $adFeeSum = 0;
464.         foreach($this->orderProduct as $op){
465.             $adFeeSum += $op->getAdministrationFee();
466.         }
468.         return $adFeeSum;
469.     }
471.     public function setAdministrationFee(int $administrationFee): self
472.     {
473.         $this->administrationFee = $administrationFee;
475.         return $this;
476.     }
478.     public function getRanking(): ?int
479.     {
480.         return $this->ranking;
481.     }
483.     public function setRanking(?int $ranking): self
484.     {
485.         $this->ranking = $ranking;
487.         return $this;
488.     }
490.     public function getInvoiceNumber(): ?string
491.     {
492.         return $this->invoiceNumber;
493.     }
495.     public function setInvoiceNumber(?string $invoiceNumber): self
496.     {
497.         $this->invoiceNumber = $invoiceNumber;
499.         return $this;
500.     }
502.     public function getInvoiceIssueDate(): ?DateTimeInterface
503.     {
504.         return $this->invoiceIssueDate;
505.     }
507.     public function setInvoiceIssueDate(?DateTimeInterface $invoiceIssueDate): self
508.     {
509.         $this->invoiceIssueDate = $invoiceIssueDate;
511.         return $this;
512.     }
514.     public function isOptimaInvoiceAdded(): ?bool
515.     {
516.         return $this->optimaInvoiceAdded;
517.     }
519.     public function setOptimaInvoiceAdded(bool $optimaInvoiceAdded): static
520.     {
521.         $this->optimaInvoiceAdded = $optimaInvoiceAdded;
523.         return $this;
524.     }
526.     public function getOptimaInvoiceAddedAt(): ?DateTimeInterface
527.     {
528.         return $this->optimaInvoiceAddedAt;
529.     }
531.     public function setOptimaInvoiceAddedAt(?DateTimeInterface $optimaInvoiceAddedAt): static
532.     {
533.         $this->optimaInvoiceAddedAt = $optimaInvoiceAddedAt;
535.         return $this;
536.     }
538.     public function getPaymentDate(): ?DateTimeInterface
539.     {
540.         return $this->paymentDate;
541.     }
543.     public function setPaymentDate(?DateTimeInterface $paymentDate): self
544.     {
545.         $this->paymentDate = $paymentDate;
547.         return $this;
548.     }
550.     public function getDateOfPayment(): ?DateTimeInterface
551.     {
552.         return $this->dateOfPayment;
553.     }
555.     public function setDateOfPayment(?DateTimeInterface $dateOfPayment): self
556.     {
557.         $this->dateOfPayment = $dateOfPayment;
559.         return $this;
560.     }
562.     public function isEnded(): ?bool
563.     {
564.         return $this->ended;
565.     }
567.     public function setEnded(bool $ended): self
568.     {
569.         $this->ended = $ended;
571.         return $this;
572.     }
574.     public function getContractExpirationDate(): ?DateTimeInterface
575.     {
576.         return $this->contractExpirationDate;
577.     }
579.     public function setContractExpirationDate(?DateTimeInterface $contractExpirationDate): self
580.     {
581.         $this->contractExpirationDate = $contractExpirationDate;
583.         return $this;
584.     }
586.     public function isFixedTerm(): ?bool
587.     {
588.         return $this->fixedTerm;
589.     }
591.     public function setFixedTerm(bool $fixedTerm): self
592.     {
593.         $this->fixedTerm = $fixedTerm;
595.         return $this;
596.     }
598.     public function isContractEnded(): ?bool
599.     {
600.         return $this->contractEnded;
601.     }
603.     public function setContractEnded(bool $contractEnded): self
604.     {
605.         $this->contractEnded = $contractEnded;
607.         return $this;
608.     }
610.     public function getContractNumber(): ?string
611.     {
612.         return $this->contractNumber;
613.     }
615.     public function setContractNumber(?string $contractNumber): self
616.     {
617.         $this->contractNumber = $contractNumber;
619.         return $this;
620.     }
622.     public function isChecked(): ?bool
623.     {
624.         return $this->checked;
625.     }
627.     public function setChecked(bool $checked): self
628.     {
629.         $this->checked = $checked;
631.         return $this;
632.     }
634.     public function isFirstOrder(): ?bool
635.     {
636.         return $this->firstOrder;
637.     }
639.     public function setFirstOrder(bool $firstOrder): self
640.     {
641.         $this->firstOrder = $firstOrder;
643.         return $this;
644.     }
646.     public function getImplementer(): Collection
647.     {
648.         return $this->implementer;
649.     }
651.     public function addImplementer(Implementer $implementer): self
652.     {
653.         if (!$this->implementer->contains($implementer)) {
654.             $this->implementer->add($implementer);
655.         }
657.         return $this;
658.     }
660.     public function removeImplementer(Implementer $implementer): self
661.     {
662.         $this->implementer->removeElement($implementer);
664.         return $this;
665.     }
667.     public function getAllImplementers(): array
668.     {
669.         $implementers = [];
670.         $orderProducts = $this->getOrderProduct();
671.         foreach ($orderProducts as $orderProduct) {
672.             $implementersOrderProducts = $orderProduct->getImplementerOrderProducts();
673.             foreach ($implementersOrderProducts as $implementersOrderProduct) {
674.                 if(count($implementersOrderProduct->getProduct()->getChildProducts())===0) {
675.                     $iopImplementers = $implementersOrderProduct->getImplementer();
676.                     foreach ($iopImplementers as $iopImplementer) {
677.                         if (!in_array($iopImplementer, $implementers)) {
678.                             $implementers[] = $iopImplementer;
679.                         }
680.                     }
681.                 }
682.             }
683.         }
685.         return $implementers;
686.     }
688.     public function getAllImplementersForNotCompletedAndNotNeeded(): array
689.     {
690.         $implementers = [];
691.         $orderProducts = $this->getOrderProduct();
692.         foreach ($orderProducts as $orderProduct) {
693.             $implementersOrderProducts = $orderProduct->getImplementerOrderProducts();
694.             foreach ($implementersOrderProducts as $implementersOrderProduct) {
695.                 $status = $implementersOrderProduct->getStatus();
696.                 if ($status === null || (!$status->isEnding() && !$status->isNotNeeded())) {
697.                     if(count($implementersOrderProduct->getProduct()->getChildProducts())===0) {
698.                         $iopImplementers = $implementersOrderProduct->getImplementer();
699.                         foreach ($iopImplementers as $iopImplementer) {
700.                             if (!in_array($iopImplementer, $implementers)) {
701.                                 $implementers[] = $iopImplementer;
702.                             }
703.                         }
704.                     }
705.                 }
706.             }
707.         }
709.         return $implementers;
710.     }
712.     public function getInspector(): ?string
713.     {
714.         return $this->inspector;
715.     }
717.     public function setInspector(?string $inspector): self
718.     {
719.         $this->inspector = $inspector;
721.         return $this;
722.     }
724.     public function isImplementationCompleted(): ?bool
725.     {
726.         return $this->implementationCompleted;
727.     }
729.     public function setImplementationCompleted(bool $implementationCompleted): self
730.     {
731.         $this->implementationCompleted = $implementationCompleted;
733.         return $this;
734.     }
736.     public function getImplementationCompletedDate(): ?DateTimeInterface
737.     {
738.         return $this->implementationCompletedDate;
739.     }
741.     public function setImplementationCompletedDate(?DateTimeInterface $implementationCompletedDate): self
742.     {
743.         $this->implementationCompletedDate = $implementationCompletedDate;
745.         return $this;
746.     }
748.     public function getParentOrder(): ?self
749.     {
750.         return $this->parentOrder;
751.     }
753.     public function setParentOrder(?self $parentOrder): self
754.     {
755.         $this->parentOrder = $parentOrder;
757.         return $this;
758.     }
760.     public function isContractExtended(): ?bool
761.     {
762.         return $this->contractExtended;
763.     }
765.     public function setContractExtended(bool $contractExtended): self
766.     {
767.         $this->contractExtended = $contractExtended;
769.         return $this;
770.     }
772.     public function isFirstContract(): ?bool
773.     {
774.         return $this->firstContract;
775.     }
777.     public function setFirstContract(bool $firstContract): self
778.     {
779.         $this->firstContract = $firstContract;
781.         return $this;
782.     }
784.     public function isContractSigned(): ?bool
785.     {
786.         return $this->contractSigned;
787.     }
789.     public function setContractSigned(bool $contractSigned): self
790.     {
791.         $this->contractSigned = $contractSigned;
793.         return $this;
794.     }
796.     public function getToken(): ?string
797.     {
798.         return $this->token;
799.     }
801.     public function setToken(?string $token): self
802.     {
803.         $this->token = $token;
805.         return $this;
806.     }
808.     public function isAutomaticallyExtended(): ?bool
809.     {
810.         return $this->automaticallyExtended;
811.     }
813.     public function setAutomaticallyExtended(bool $automaticallyExtended): self
814.     {
815.         $this->automaticallyExtended = $automaticallyExtended;
816.         ($automaticallyExtended)?$this->setNoticeDate(NULL):$this->setNoticeDate(new DateTime());
818.         return $this;
819.     }
821.     public function getTokenOffice(): ?string
822.     {
823.         return $this->tokenOffice;
824.     }
826.     public function setTokenOffice(?string $tokenOffice): self
827.     {
828.         $this->tokenOffice = $tokenOffice;
830.         return $this;
831.     }
833.     public function getRecommendedNumber(): ?int
834.     {
835.         return $this->recommendedNumber;
836.     }
838.     public function setRecommendedNumber(?int $recommendedNumber): self
839.     {
840.         $this->recommendedNumber = $recommendedNumber;
842.         return $this;
843.     }
845.     public function getOfficeInvoice(): ?string
846.     {
847.         return $this->officeInvoice;
848.     }
850.     public function setOfficeInvoice(?string $officeInvoice): self
851.     {
852.         $this->officeInvoice = $officeInvoice;
854.         return $this;
855.     }
857.     public function getCommissionPercentage(): ?int
858.     {
859.         return $this->commissionPercentage;
860.     }
862.     public function setCommissionPercentage(?int $commissionPercentage): self
863.     {
864.         $this->commissionPercentage = $commissionPercentage;
866.         return $this;
867.     }
869.     public function getActivationAmmount(): ?int
870.     {
871.         return $this->activationAmmount;
872.     }
874.     public function setActivationAmmount(?int $activationAmmount): self
875.     {
876.         $this->activationAmmount = $activationAmmount;
878.         return $this;
879.     }
881.     public function isOfficeContractEnded(): ?bool
882.     {
883.         return $this->officeContractEnded;
884.     }
886.     public function setOfficeContractEnded(bool $officeContractEnded): self
887.     {
888.         $this->officeContractEnded = $officeContractEnded;
890.         return $this;
891.     }
893.     public function getBhpPackage(): ?int
894.     {
895.         return $this->bhpPackage;
896.     }
898.     public function setBhpPackage(int $bhpPackage): self
899.     {
900.         $this->bhpPackage = $bhpPackage;
902.         return $this;
903.     }
905.     public function getTokenBhpRodo(): ?string
906.     {
907.         return $this->tokenBhpRodo;
908.     }
910.     public function setTokenBhpRodo(?string $tokenBhpRodo): self
911.     {
912.         $this->tokenBhpRodo = $tokenBhpRodo;
914.         return $this;
915.     }
917.     public function getReward(): ?int
918.     {
919.         return $this->reward;
920.     }
922.     public function setReward(?int $reward): self
923.     {
924.         $this->reward = $reward;
926.         return $this;
927.     }
929.     public function getTokenIod(): ?string
930.     {
931.         return $this->tokenIod;
932.     }
934.     public function setTokenIod(?string $tokenIod): self
935.     {
936.         $this->tokenIod = $tokenIod;
938.         return $this;
939.     }
941.     public function getTokenBdo(): ?string
942.     {
943.         return $this->tokenBdo;
944.     }
946.     public function setTokenBdo(?string $tokenBdo): self
947.     {
948.         $this->tokenBdo = $tokenBdo;
950.         return $this;
951.     }
953.     public function getTokenBhpStationary(): ?string
954.     {
955.         return $this->tokenBhpStationary;
956.     }
958.     public function setTokenBhpStationary(?string $tokenBhpStationary): self
959.     {
960.         $this->tokenBhpStationary = $tokenBhpStationary;
962.         return $this;
963.     }
965.     public function isAuditReady(): ?bool
966.     {
967.         return $this->auditReady;
968.     }
970.     public function setAuditReady(bool $auditReady): self
971.     {
972.         $this->auditReady = $auditReady;
974.         return $this;
975.     }
977.     public function isAuditEnded(): ?bool
978.     {
979.         return $this->auditEnded;
980.     }
982.     public function setAuditEnded(bool $auditEnded): self
983.     {
984.         $this->auditEnded = $auditEnded;
986.         return $this;
987.     }
989.     public function isContractWithoutCourses(): ?bool
990.     {
991.         return $this->contractWithoutCourses;
992.     }
994.     public function setContractWithoutCourses(bool $contractWithoutCourses): self
995.     {
996.         $this->contractWithoutCourses = $contractWithoutCourses;
998.         return $this;
999.     }
1001.     public function getOrderHistories(): Collection
1002.     {
1003.         return $this->orderHistories;
1004.     }
1006.     public function addOrderHistory(OrderHistory $orderHistory): self
1007.     {
1008.         if (!$this->orderHistories->contains($orderHistory)) {
1009.             $this->orderHistories->add($orderHistory);
1010.             $orderHistory->setOrderId($this);
1011.         }
1013.         return $this;
1014.     }
1016.     public function removeOrderHistory(OrderHistory $orderHistory): self
1017.     {
1018.         if ($this->orderHistories->removeElement($orderHistory)) {
1019.             if ($orderHistory->getOrderId() === $this) {
1020.                 $orderHistory->setOrderId(null);
1021.             }
1022.         }
1024.         return $this;
1025.     }
1027.     public function getCustomer(): ?Customer
1028.     {
1029.         return $this->customer;
1030.     }
1032.     public function setCustomer(?Customer $customer): self
1033.     {
1034.         $this->customer = $customer;
1036.         return $this;
1037.     }
1039.     public function getCustomerAddress(): ?CustomerAddress
1040.     {
1041.         return $this->customerAddress;
1042.     }
1044.     public function setCustomerAddress(?CustomerAddress $customerAddress): self
1045.     {
1046.         $this->customerAddress = $customerAddress;
1048.         return $this;
1049.     }
1051.     public function getOrderProduct(): Collection
1052.     {
1053.         return $this->orderProduct;
1054.     }
1056.     public function addOrderProduct(OrderProduct $orderProduct): self
1057.     {
1058.         if (!$this->orderProduct->contains($orderProduct)) {
1059.             $this->orderProduct->add($orderProduct);
1060.             $orderProduct->setOrderId($this);
1061.         }
1063.         return $this;
1064.     }
1066.     public function removeOrderProduct(OrderProduct $orderProduct): self
1067.     {
1068.         if ($this->orderProduct->removeElement($orderProduct)) {
1069.             if ($orderProduct->getOrderId() === $this) {
1070.                 $orderProduct->setOrderId(null);
1071.             }
1072.         }
1074.         return $this;
1075.     }
1077.     public function getPriceTotal(): float
1078.     {
1079.         $sum = 0;
1080.         $products = $this->getOrderProduct();
1081.         foreach ($products as $product) {
1082.             $sum = $sum + (($product->getPriceSubtotal() * $product->getQuantity()) * (1 + ($product->getProduct()->getTax() / 100)));
1083.         }
1085.         return $this->ceiling($sum,2);
1086.     }
1088.     function ceiling($value, int $precision = 0) {
1089.         $offset = 0.5;
1090.         if ($precision !== 0)
1091.             $offset /= pow(10, $precision);
1092.         $final = round($value + $offset, $precision, PHP_ROUND_HALF_DOWN);
1093.         return ($final == -0 ? 0 : $final);
1094.     }
1096.     public function getPriceSubtotal(): float
1097.     {
1098.         $sum = 0;
1099.         $products = $this->getOrderProduct();
1100.         foreach ($products as $product) {
1101.             $sum = $sum + ($product->getPriceSubtotal() * $product->getQuantity());
1102.         }
1104.         return $sum;
1105.     }
1107.     public function getPrices(): array
1108.     {
1109.         return [
1110.             'subtotal' => number_format($this->getPriceSubtotal(), 2),
1111.             'total' => number_format($this->getPriceTotal(), 2),
1112.         ];
1113.     }
1115.     public function getFirstOrderString(): string
1116.     {
1117.         return $this->isFirstOrder();
1118.     }
1120.     public function getBranch(): ?Branch
1121.     {
1122.         return $this->branch;
1123.     }
1125.     public function setBranch(?Branch $branch): static
1126.     {
1127.         $this->branch = $branch;
1129.         return $this;
1130.     }
1132.     public function getContract(): ?Contract
1133.     {
1134.         return $this->contract;
1135.     }
1137.     public function setContract(?Contract $contract): static
1138.     {
1139.         $this->contract = $contract;
1141.         return $this;
1142.     }
1144.     /**
1145.      * @return Collection<int, Instalments>
1146.      */
1147.     public function getInstalments(): Collection
1148.     {
1149.         return $this->instalments;
1150.     }
1152.     public function addInstalment(Instalments $instalment): static
1153.     {
1154.         if (!$this->instalments->contains($instalment)) {
1155.             $this->instalments->add($instalment);
1156.             $instalment->setOrderInstance($this);
1157.         }
1159.         return $this;
1160.     }
1162.     public function removeInstalment(Instalments $instalment): static
1163.     {
1164.         if ($this->instalments->removeElement($instalment)) {
1165.             // set the owning side to null (unless already changed)
1166.             if ($instalment->getOrderInstance() === $this) {
1167.                 $instalment->setOrderInstance(null);
1168.             }
1169.         }
1171.         return $this;
1172.     }
1174.     public function isInstalment(): ?bool
1175.     {
1176.         return $this->instalment;
1177.     }
1179.     public function setInstalment(bool $instalment): static
1180.     {
1181.         $this->instalment = $instalment;
1183.         return $this;
1184.     }
1186.     public function getContractIndividual(): ?ContractIndividual
1187.     {
1188.         return $this->contractIndividual;
1189.     }
1191.     public function setContractIndividual(?ContractIndividual $contractIndividual): static
1192.     {
1193.         $this->contractIndividual = $contractIndividual;
1195.         return $this;
1196.     }
1198.     public function isNeedContract(): ?bool
1199.     {
1200.         return $this->needContract;
1201.     }
1203.     public function setNeedContract(?bool $needContract): static
1204.     {
1205.         $this->needContract = $needContract;
1207.         return $this;
1208.     }
1210.     /**
1211.      * @return Collection<int, ImplementerOrderHistory>
1212.      */
1213.     public function getImplementerOrderHistories(): Collection
1214.     {
1215.         return $this->implementerOrderHistories;
1216.     }
1218.     public function addImplementerOrderHistory(ImplementerOrderHistory $implementerOrderHistory): static
1219.     {
1220.         if (!$this->implementerOrderHistories->contains($implementerOrderHistory)) {
1221.             $this->implementerOrderHistories->add($implementerOrderHistory);
1222.             $implementerOrderHistory->setOrderId($this);
1223.         }
1225.         return $this;
1226.     }
1228.     public function removeImplementerOrderHistory(ImplementerOrderHistory $implementerOrderHistory): static
1229.     {
1230.         if ($this->implementerOrderHistories->removeElement($implementerOrderHistory)) {
1231.             // set the owning side to null (unless already changed)
1232.             if ($implementerOrderHistory->getOrderId() === $this) {
1233.                 $implementerOrderHistory->setOrderId(null);
1234.             }
1235.         }
1237.         return $this;
1238.     }
1240.     public function getImplementerOrderData(): ?ImplementerOrderData
1241.     {
1242.         return $this->implementerOrderData;
1243.     }
1245.     public function setImplementerOrderData(ImplementerOrderData $implementerOrderData): static
1246.     {
1247.         // set the owning side of the relation if necessary
1248.         if ($implementerOrderData->getOrderId() !== $this) {
1249.             $implementerOrderData->setOrderId($this);
1250.         }
1252.         $this->implementerOrderData = $implementerOrderData;
1254.         return $this;
1255.     }
1257.     /**
1258.      * @return Collection<int, OrderNote>
1259.      */
1260.     public function getOrderNotes(): Collection
1261.     {
1262.         return $this->orderNotes;
1263.     }
1265.     public function addOrderNote(OrderNote $orderNote): static
1266.     {
1267.         if (!$this->orderNotes->contains($orderNote)) {
1268.             $this->orderNotes->add($orderNote);
1269.             $orderNote->setOrderInstance($this);
1270.         }
1272.         return $this;
1273.     }
1275.     public function removeOrderNote(OrderNote $orderNote): static
1276.     {
1277.         if ($this->orderNotes->removeElement($orderNote)) {
1278.             // set the owning side to null (unless already changed)
1279.             if ($orderNote->getOrderInstance() === $this) {
1280.                 $orderNote->setOrderInstance(null);
1281.             }
1282.         }
1284.         return $this;
1285.     }
1287.     public function getOrderDividedConsultant(): ?Consultant
1288.     {
1289.         return $this->orderDividedConsultant;
1290.     }
1292.     public function setOrderDividedConsultant(?Consultant $orderDividedConsultant): static
1293.     {
1294.         $this->orderDividedConsultant = $orderDividedConsultant;
1296.         return $this;
1297.     }
1299.     /**
1300.      * @return Collection<int, BhpOrderProduct>
1301.      */
1302.     public function getBhpOrderProducts(): Collection
1303.     {
1304.         return $this->BhpOrderProducts;
1305.     }
1307.     public function addBhpOrderProduct(BhpOrderProduct $BhpOrderProduct): static
1308.     {
1309.         if (!$this->BhpOrderProducts->contains($BhpOrderProduct)) {
1310.             $this->BhpOrderProducts->add($BhpOrderProduct);
1311.             $BhpOrderProduct->setOrderInstance($this);
1312.         }
1314.         return $this;
1315.     }
1316.     public function getAdmin(): ?Admin
1317.     {
1318.         return $this->admin;
1319.     }
1321.     public function setAdmin(?Admin $admin): static
1322.     {
1323.         $this->admin = $admin;
1325.         return $this;
1326.     }
1328.     public function removeBhpOrderProduct(BhpOrderProduct $BhpOrderProduct): static
1329.     {
1330.         if ($this->BhpOrderProducts->removeElement($BhpOrderProduct)) {
1331.             // set the owning side to null (unless already changed)
1332.             if ($BhpOrderProduct->getOrderInstance() === $this) {
1333.                 $BhpOrderProduct->setOrderInstance(null);
1334.             }
1335.         }
1337.         return $this;
1338.     }
1340.     public function isDoBeforePayment(): ?bool
1341.     {
1342.         return $this->doBeforePayment;
1343.     }
1345.     public function setDoBeforePayment(bool $doBeforePayment): static
1346.     {
1347.         $this->doBeforePayment = $doBeforePayment;
1349.         return $this;
1350.     }
1352.     public function getOldOrderId(): ?int
1353.     {
1354.         return $this->oldOrderId;
1355.     }
1357.     public function setOldOrderId(?int $oldOrderId): static
1358.     {
1359.         $this->oldOrderId = $oldOrderId;
1361.         return $this;
1362.     }
1364.     public function getAdministrationFeeSum()
1365.     {
1366.         $orderProductAdministrationSum = 0;
1367.         foreach($this->orderProduct as $orderProduct){
1368.             $orderProductAdministrationSum += $orderProduct->getAdministrationFee();
1369.         }
1371.         return $orderProductAdministrationSum;
1372.     }
1374.     /**
1375.      * @return Collection<int, AccountingOfficeCategory>
1376.      */
1377.     public function getAccountingOfficeCategories(): Collection
1378.     {
1379.         return $this->accountingOfficeCategories;
1380.     }
1382.     public function addAccountingOfficeCategory(AccountingOfficeCategory $accountingOfficeCategory): static
1383.     {
1384.         if (!$this->accountingOfficeCategories->contains($accountingOfficeCategory)) {
1385.             $this->accountingOfficeCategories->add($accountingOfficeCategory);
1386.             $accountingOfficeCategory->setOrderInstance($this);
1387.         }
1389.         return $this;
1390.     }
1392.     public function removeAccountingOfficeCategory(AccountingOfficeCategory $accountingOfficeCategory): static
1393.     {
1394.         if ($this->accountingOfficeCategories->removeElement($accountingOfficeCategory)) {
1395.             // set the owning side to null (unless already changed)
1396.             if ($accountingOfficeCategory->getOrderInstance() === $this) {
1397.                 $accountingOfficeCategory->setOrderInstance(null);
1398.             }
1399.         }
1401.         return $this;
1402.     }
1404.     /**
1405.      * @return Collection<int, BhpJournals>
1406.      */
1407.     public function getBhpJournals(): Collection
1408.     {
1409.         return $this->bhpJournals;
1410.     }
1412.     public function addBhpJournal(BhpJournals $bhpJournal): static
1413.     {
1414.         if (!$this->bhpJournals->contains($bhpJournal)) {
1415.             $this->bhpJournals->add($bhpJournal);
1416.             $bhpJournal->setOrderInstance($this);
1417.         }
1419.         return $this;
1420.     }
1422.     public function removeBhpJournal(BhpJournals $bhpJournal): static
1423.     {
1424.         if ($this->bhpJournals->removeElement($bhpJournal)) {
1425.             // set the owning side to null (unless already changed)
1426.             if ($bhpJournal->getOrderInstance() === $this) {
1427.                 $bhpJournal->setOrderInstance(null);
1428.             }
1429.         }
1431.         return $this;
1432.     }
1434.     public function getTokenAml(): ?string
1435.     {
1436.         return $this->tokenAml;
1437.     }
1439.     public function setTokenAml(?string $tokenAml): static
1440.     {
1441.         $this->tokenAml = $tokenAml;
1443.         return $this;
1444.     }
1446.     public function getTokenAmlrodo(): ?string
1447.     {
1448.         return $this->tokenAmlrodo;
1449.     }
1451.     public function setTokenAmlrodo(?string $tokenAmlrodo): static
1452.     {
1453.         $this->tokenAmlrodo = $tokenAmlrodo;
1455.         return $this;
1456.     }
1458.     public function isWithUmowa():bool
1459.     {
1460.         $umowa = false;
1461.         foreach($this->getOrderProduct() as $orderProduct){
1462.             if($orderProduct->getProduct()->isUmowa()){
1463.                 $umowa = true;
1464.                 break;
1465.             }
1466.         }
1467.         return $umowa;
1468.     }
1470.     public function isWithAneks():bool
1471.     {
1472.         $umowa = false;
1473.         foreach($this->getOrderProduct() as $orderProduct){
1474.             if($orderProduct->getProduct()->isAneks()){
1475.                 $umowa = true;
1476.                 break;
1477.             }
1478.         }
1479.         return $umowa;
1480.     }
1482.     public function hasProductWithLicenseType(): bool
1483.     {
1484.         foreach ($this->getOrderProduct() as $orderProduct) {
1485.             $product = $orderProduct->getProduct();
1486.             if ($product !== null && trim((string) $product->getLicenseType()) !== '') {
1487.                 return true;
1488.             }
1489.         }
1491.         return false;
1492.     }
1494.     /**
1495.      * @return array<int, self>
1496.      */
1497.     public function getSignedAneksOrders(): array
1498.     {
1499.         return array_values(array_filter(
1500.             $this->aneksOrders->toArray(),
1501.             static fn (self $aneksOrder): bool => $aneksOrder->isContractSigned() === true
1502.         ));
1503.     }
1505.     public function hasSignedAneksOrders(): bool
1506.     {
1507.         return count($this->getSignedAneksOrders()) > 0;
1508.     }
1510.     public function getSignedAneksOrdersSubtotal(): float
1511.     {
1512.         $sum = 0.0;
1513.         foreach ($this->getSignedAneksOrders() as $aneksOrder) {
1514.             $sum += $aneksOrder->getPriceSubtotal();
1515.         }
1517.         return $sum;
1518.     }
1520.     /**
1521.      * @return array<int, self>
1522.      */
1523.     public function getSignedAneksOrdersToAddOnNextExtension(): array
1524.     {
1525.         $aneksOrders = [];
1527.         foreach ($this->getSignedAneksOrders() as $aneksOrder) {
1528.             if ($this->shouldAddAneksOnFirstExtension($aneksOrder)) {
1529.                 $aneksOrders[] = $aneksOrder;
1530.             }
1531.         }
1533.         $parentOrder = $this->getParentOrder();
1534.         if ($parentOrder !== null) {
1535.             foreach ($parentOrder->getSignedAneksOrders() as $aneksOrder) {
1536.                 if (!$parentOrder->shouldAddAneksOnFirstExtension($aneksOrder)) {
1537.                     $aneksOrders[] = $aneksOrder;
1538.                 }
1539.             }
1540.         }
1542.         return $this->uniqueOrders($aneksOrders);
1543.     }
1545.     public function getSignedAneksOrdersSubtotalToAddOnNextExtension(): float
1546.     {
1547.         $sum = 0.0;
1548.         foreach ($this->getSignedAneksOrdersToAddOnNextExtension() as $aneksOrder) {
1549.             $sum += $aneksOrder->getPriceSubtotal();
1550.         }
1552.         return $sum;
1553.     }
1555.     /**
1556.      * @return array<int, self>
1557.      */
1558.     public function getSignedAneksOrdersSkippedOnNextExtension(): array
1559.     {
1560.         $aneksOrders = [];
1561.         foreach ($this->getSignedAneksOrders() as $aneksOrder) {
1562.             if (!$this->shouldAddAneksOnFirstExtension($aneksOrder)) {
1563.                 $aneksOrders[] = $aneksOrder;
1564.             }
1565.         }
1567.         return $this->uniqueOrders($aneksOrders);
1568.     }
1570.     private function shouldAddAneksOnFirstExtension(self $aneksOrder): bool
1571.     {
1572.         $contractSignedDate = $this->getContractSignedDate();
1573.         $aneksSignedDate = $aneksOrder->getContractSignedDate();
1575.         if ($contractSignedDate === null || $aneksSignedDate === null) {
1576.             return true;
1577.         }
1579.         $sixMonthsBeforeAneks = (clone $aneksSignedDate)->modify('-6 months');
1581.         return $contractSignedDate <= $sixMonthsBeforeAneks;
1582.     }
1584.     /**
1585.      * @param array<int, self> $orders
1586.      *
1587.      * @return array<int, self>
1588.      */
1589.     private function uniqueOrders(array $orders): array
1590.     {
1591.         $uniqueOrders = [];
1592.         foreach ($orders as $order) {
1593.             $key = $order->getId() ?? spl_object_id($order);
1594.             $uniqueOrders[$key] = $order;
1595.         }
1597.         return array_values($uniqueOrders);
1598.     }
1600.     public function getDebtStatus(): ?DebtStatus
1601.     {
1602.         return $this->debtStatus;
1603.     }
1605.     public function setDebtStatus(?DebtStatus $debtStatus): static
1606.     {
1607.         $this->debtStatus = $debtStatus;
1609.         return $this;
1610.     }
1612.     public function isDebtCollection(): ?bool
1613.     {
1614.         return $this->debtCollection;
1615.     }
1617.     public function setDebtCollection(bool $debtCollection): static
1618.     {
1619.         $this->debtCollection = $debtCollection;
1621.         return $this;
1622.     }
1624.     public function getDebtContactDate(): ?\DateTimeInterface
1625.     {
1626.         return $this->debtContactDate;
1627.     }
1629.     public function setDebtContactDate(?\DateTimeInterface $debtContactDate): static
1630.     {
1631.         $this->debtContactDate = $debtContactDate;
1633.         return $this;
1634.     }
1636.     /**
1637.      * @return Collection<int, DebtNote>
1638.      */
1639.     public function getDebtNotes(): Collection
1640.     {
1641.         return $this->debtNotes;
1642.     }
1644.     public function addDebtNote(DebtNote $debtNote): static
1645.     {
1646.         if (!$this->debtNotes->contains($debtNote)) {
1647.             $this->debtNotes->add($debtNote);
1648.             $debtNote->setOrderId($this);
1649.         }
1651.         return $this;
1652.     }
1654.     public function removeDebtNote(DebtNote $debtNote): static
1655.     {
1656.         if ($this->debtNotes->removeElement($debtNote)) {
1657.             // set the owning side to null (unless already changed)
1658.             if ($debtNote->getOrderId() === $this) {
1659.                 $debtNote->setOrderId(null);
1660.             }
1661.         }
1663.         return $this;
1664.     }
1666.     public function getLittleNote(): ?string
1667.     {
1668.         return $this->littleNote;
1669.     }
1671.     public function setLittleNote(?string $littleNote): static
1672.     {
1673.         $this->littleNote = $littleNote;
1675.         return $this;
1676.     }
1678.     public function getOrderCustomer(): ?OrderCustomer
1679.     {
1680.         return $this->orderCustomer;
1681.     }
1683.     public function setOrderCustomer(OrderCustomer $orderCustomer): static
1684.     {
1685.         // set the owning side of the relation if necessary
1686.         if ($orderCustomer->getOrderId() !== $this) {
1687.             $orderCustomer->setOrderId($this);
1688.         }
1690.         $this->orderCustomer = $orderCustomer;
1692.         return $this;
1693.     }
1695.     public function getOrderCustomerAddress(): ?OrderCustomerAddress
1696.     {
1697.         return $this->orderCustomerAddress;
1698.     }
1700.     public function setOrderCustomerAddress(OrderCustomerAddress $orderCustomerAddress): static
1701.     {
1702.         // set the owning side of the relation if necessary
1703.         if ($orderCustomerAddress->getOrderId() !== $this) {
1704.             $orderCustomerAddress->setOrderId($this);
1705.         }
1707.         $this->orderCustomerAddress = $orderCustomerAddress;
1709.         return $this;
1710.     }
1712.     public function getContractSignedDate(): ?\DateTimeInterface
1713.     {
1714.         return $this->contractSignedDate;
1715.     }
1717.     public function setContractSignedDate(?\DateTimeInterface $contractSignedDate): static
1718.     {
1719.         $this->contractSignedDate = $contractSignedDate;
1721.         return $this;
1722.     }
1724.     /**
1726.      * @return Collection<int, OrderDivided>
1727.      */
1728.     public function getOrderDivideds(): Collection
1729.     {
1730.         return $this->orderDivideds;
1731.     }
1733.     public function addOrderDivided(OrderDivided $orderDivided): static
1734.     {
1735.         if (!$this->orderDivideds->contains($orderDivided)) {
1736.             $this->orderDivideds->add($orderDivided);
1737.             $orderDivided->setOrderId($this);
1738.         }
1740.         return $this;
1741.     }
1743.     /**
1744.      * @return Collection<int, MailHistory>
1745.      */
1746.     public function getMailHistories(): Collection
1747.     {
1748.         return $this->mailHistories;
1749.     }
1751.     public function addMailHistory(MailHistory $mailHistory): static
1752.     {
1753.         if (!$this->mailHistories->contains($mailHistory)) {
1754.             $this->mailHistories->add($mailHistory);
1755.             $mailHistory->setOrderInstance($this);
1756.         }
1758.         return $this;
1759.     }
1761.     public function removeOrderDivided(OrderDivided $orderDivided): static
1762.     {
1763.         if ($this->orderDivideds->removeElement($orderDivided)) {
1764.             // set the owning side to null (unless already changed)
1765.             if ($orderDivided->getOrderId() === $this) {
1766.                 $orderDivided->setOrderId(null);
1767.             }
1768.         }
1770.         return $this;
1771.     }
1773.     public function removeMailHistory(MailHistory $mailHistory): static
1774.     {
1775.         if ($this->mailHistories->removeElement($mailHistory)) {
1776.             // set the owning side to null (unless already changed)
1777.             if ($mailHistory->getOrderInstance() === $this) {
1778.                 $mailHistory->setOrderInstance(null);
1780.             }
1781.         }
1783.         return $this;
1784.     }
1786.     public function getOrderDividedSum(): float
1787.     {
1788.         $sum = 0;
1789.         foreach($this->getOrderDivideds() as $orderDivided){
1790.             $sum = $sum+$orderDivided->getValue();
1791.         }
1793.         return $sum;
1794.     }
1796.     public function isHaveInstalments(): ?bool
1797.     {
1798.         return $this->haveInstalments;
1799.     }
1801.     public function setHaveInstalments(bool $haveInstalments): static
1802.     {
1803.         $this->haveInstalments = $haveInstalments;
1805.         return $this;
1806.     }
1808.     public function getOrderNoteForExtension(): ?OrderNote
1809.     {
1810.         return $this->orderNoteForExtension;
1811.     }
1813.     public function setOrderNoteForExtension(?OrderNote $orderNoteForExtension): static
1814.     {
1815.         $this->orderNoteForExtension = $orderNoteForExtension;
1817.         return $this;
1818.     }
1820.     public function isImplementationCompletedWithoutAudit(): ?bool
1821.     {
1822.         return $this->implementationCompletedWithoutAudit;
1823.     }
1825.     public function setImplementationCompletedWithoutAudit(bool $implementationCompletedWithoutAudit): static
1826.     {
1827.         $this->implementationCompletedWithoutAudit = $implementationCompletedWithoutAudit;
1829.         return $this;
1830.     }
1832.     public function getDebtStatusChangeDate(): ?\DateTimeInterface
1833.     {
1834.         return $this->debtStatusChangeDate;
1835.     }
1837.     public function setDebtStatusChangeDate(?\DateTimeInterface $debtStatusChangeDate): static
1838.     {
1839.         $this->debtStatusChangeDate = $debtStatusChangeDate;
1841.         return $this;
1842.     }
1844.     /**
1845.      * @return Collection<int, Consultant>
1846.      */
1847.     public function getConsultantForNotes(): Collection
1848.     {
1849.         return $this->consultantForNotes;
1850.     }
1852.     /**
1853.      * @return Collection<int, Consultant>|Consultant|Admin
1854.      */
1855.     public function getCurrentConsultantsOrAdmin(): Collection|Consultant|Admin
1856.     {
1857.         $dateTimeNow = new DateTime();
1859.         $paymentDate = $this->getPaymentDate();
1860.         $dateOfPayment = $this->getDateOfPayment();
1862.         $consultant = $this->consultant;
1863.         $admin = $this->getAdmin();
1865.         $consultantsForNotes = $this->getConsultantForNotes();
1867.         if (empty($dateOfPayment) && $paymentDate !== null && $dateTimeNow > $paymentDate && !$consultantsForNotes->isEmpty()) {
1868.             return $consultantsForNotes;
1869.         } else {
1870.             return $consultant ?? $admin;
1871.         }
1872.     }
1874.     public function addConsultantForNote(Consultant $consultantForNote): static
1875.     {
1876.         if (!$this->consultantForNotes->contains($consultantForNote)) {
1877.             $this->consultantForNotes->add($consultantForNote);
1878.         }
1880.         return $this;
1881.     }
1883.     public function removeConsultantForNote(Consultant $consultantForNote): static
1884.     {
1885.         $this->consultantForNotes->removeElement($consultantForNote);
1887.         return $this;
1888.     }
1890.     /**
1891.      * @return Collection<int, Task>
1892.      */
1893.     public function getTasks(): Collection
1894.     {
1895.         return $this->tasks;
1896.     }
1898.     public function addTask(Task $task): static
1899.     {
1900.         if (!$this->tasks->contains($task)) {
1901.             $this->tasks->add($task);
1902.             $task->setOrderInstance($this);
1903.         }
1905.         return $this;
1906.     }
1908.     public function removeTask(Task $task): static
1909.     {
1910.         if ($this->tasks->removeElement($task)) {
1911.             // set the owning side to null (unless already changed)
1912.             if ($task->getOrderInstance() === $this) {
1913.                 $task->setOrderInstance(null);
1914.             }
1915.         }
1917.         return $this;
1918.     }
1920.     /**
1921.      * @return Collection<int, SmsHistory>
1922.      */
1923.     public function getSmsHistories(): Collection
1924.     {
1925.         return $this->smsHistories;
1926.     }
1928.     public function addSmsHistory(SmsHistory $smsHistory): static
1929.     {
1930.         if (!$this->smsHistories->contains($smsHistory)) {
1931.             $this->smsHistories->add($smsHistory);
1932.             $smsHistory->setOrderId($this);
1933.         }
1935.         return $this;
1936.     }
1938.     public function removeSmsHistory(SmsHistory $smsHistory): static
1939.     {
1940.         if ($this->smsHistories->removeElement($smsHistory)) {
1941.             // set the owning side to null (unless already changed)
1942.             if ($smsHistory->getOrderId() === $this) {
1943.                 $smsHistory->setOrderId(null);
1944.             }
1945.         }
1947.         return $this;
1948.     }
1950.     public function getNoticeDate(): ?\DateTimeInterface
1951.     {
1952.         return $this->noticeDate;
1953.     }
1955.     public function setNoticeDate(?\DateTimeInterface $noticeDate): static
1956.     {
1957.         $this->noticeDate = $noticeDate;
1959.         return $this;
1960.     }
1962.     /**
1963.      * @return Collection<int, SurveyResponse>
1964.      */
1965.     public function getSurveyResponses(): Collection
1966.     {
1967.         return $this->surveyResponses;
1968.     }
1970.     public function addSurveyResponse(SurveyResponse $surveyResponse): static
1971.     {
1972.         if (!$this->surveyResponses->contains($surveyResponse)) {
1973.             $this->surveyResponses->add($surveyResponse);
1974.             $surveyResponse->setOrderInstance($this);
1975.         }
1977.         return $this;
1978.     }
1980.     public function removeSurveyResponse(SurveyResponse $surveyResponse): static
1981.     {
1982.         if ($this->surveyResponses->removeElement($surveyResponse)) {
1983.             // set the owning side to null (unless already changed)
1984.             if ($surveyResponse->getOrderInstance() === $this) {
1985.                 $surveyResponse->setOrderInstance(null);
1986.             }
1987.         }
1989.         return $this;
1990.     }
1992.     /**
1993.      * @return Collection<int, ZoomList>
1994.      */
1995.     public function getZoomLists(): Collection
1996.     {
1997.         return $this->zoomLists;
1998.     }
2000.     public function addZoomList(ZoomList $zoomList): static
2001.     {
2002.         if (!$this->zoomLists->contains($zoomList)) {
2003.             $this->zoomLists->add($zoomList);
2004.             $zoomList->setOrderInstance($this);
2005.         }
2007.         return $this;
2008.     }
2010.     public function removeZoomList(ZoomList $zoomList): static
2011.     {
2012.         if ($this->zoomLists->removeElement($zoomList)) {
2013.             // set the owning side to null (unless already changed)
2014.             if ($zoomList->getOrderInstance() === $this) {
2015.                 $zoomList->setOrderInstance(null);
2016.             }
2017.         }
2019.         return $this;
2020.     }
2022.     public function getTokenLicencyjnaWebAml(): ?string
2023.     {
2024.         return $this->tokenLicencyjnaWebAml;
2025.     }
2027.     public function setTokenLicencyjnaWebAml(?string $tokenLicencyjnaWebAml): static
2028.     {
2029.         $this->tokenLicencyjnaWebAml = $tokenLicencyjnaWebAml;
2031.         return $this;
2032.     }
2034.     public function getTokenLicencyjnaWebAmlPartnerska(): ?string
2035.     {
2036.         return $this->tokenLicencyjnaWebAmlPartnerska;
2037.     }
2039.     public function setTokenLicencyjnaWebAmlPartnerska(?string $tokenLicencyjnaWebAmlPartnerska): static
2040.     {
2041.         $this->tokenLicencyjnaWebAmlPartnerska = $tokenLicencyjnaWebAmlPartnerska;
2043.         return $this;
2044.     }
2046.     public function getTokenLicencyjnaWebAmlNieruchomosci(): ?string
2047.     {
2048.         return $this->tokenLicencyjnaWebAmlNieruchomosci;
2049.     }
2051.     public function setTokenLicencyjnaWebAmlNieruchomosci(?string $tokenLicencyjnaWebAmlNieruchomosci): static
2052.     {
2053.         $this->tokenLicencyjnaWebAmlNieruchomosci = $tokenLicencyjnaWebAmlNieruchomosci;
2055.         return $this;
2056.     }
2058.     public function getDateForPoints(): ?\DateTimeInterface
2059.     {
2060.         return $this->dateForPoints;
2061.     }
2063.     public function setDateForPoints(?\DateTimeInterface $dateForPoints): static
2064.     {
2065.         $this->dateForPoints = $dateForPoints;
2067.         return $this;
2068.     }
2070.     public function isPointsAdded(): ?bool
2071.     {
2072.         return $this->pointsAdded;
2073.     }
2075.     public function setPointsAdded(bool $pointsAdded): static
2076.     {
2077.         $this->pointsAdded = $pointsAdded;
2079.         return $this;
2080.     }
2082.     public function isForCountingSprawozdaniaOther(): ?bool
2083.     {
2084.         return $this->forCountingSprawozdaniaOther;
2085.     }
2087.     public function setForCountingSprawozdaniaOther(bool $forCountingSprawozdaniaOther): static
2088.     {
2089.         $this->forCountingSprawozdaniaOther = $forCountingSprawozdaniaOther;
2091.         return $this;
2092.     }
2094.     public function getOrderProductAgreementToken(): string
2095.     {
2096.         $token = '';
2097.         foreach ($this->getOrderProduct() as $orderProduct) {
2098.             if($orderProduct->getProduct()->getAgreement()){
2099.             $token = match ($orderProduct->getProduct()->getAgreement()->getType()) {
2100.                 'rodo' => $this->getToken(),
2101.                 'aml' => $this->getTokenAml(),
2102.                 'amlrodo' => $this->getTokenAmlrodo(),
2103.                 'kontrolazarzadczajst' => $this->getTokenKontrolaZarzadczaJst(),
2104.                 'bdo' => $this->getTokenBdo(),
2105.                 'bhpstacjonarna' => $this->getTokenBhpStationary(),
2106.                 'biurarachunkowe' => $this->getTokenOffice(),
2107.                 'iod' => $this->getTokenIod(),
2108.                 'rodobhp' => $this->getTokenBhpRodo(),
2109.                 'licencyjnewebaml' => $this->getTokenLicencyjnaWebAml(),
2110.                 'licencyjnewebamlpartnerska' => $this->getTokenLicencyjnaWebAmlPartnerska(),
2111.                 'licencyjnewebamlnieruchomosci' => $this->getTokenLicencyjnaWebAmlNieruchomosci(),
2112.                 'licencyjneaneks' => $this->getAneksToken(),
2113.                 default => '',
2114.             };
2115.             if($token){
2116.                 return $token;
2117.             }else{
2118.                 return '';
2119.             }
2120.             }
2121.         }
2122.         return $token;
2123.     }
2125.     public function getOrderProductAgreementType(): string
2126.     {
2127.         $token = '';
2128.         foreach ($this->getOrderProduct() as $orderProduct) {
2129.             if($orderProduct->getProduct()->getAgreement()){
2130.                 return $orderProduct->getProduct()->getAgreement()->getType();
2131.             }
2132.         }
2133.         return $token;
2134.     }
2136.     public function isAnnex(): ?bool
2137.     {
2138.         return $this->annex;
2139.     }
2141.     public function setAnnex(bool $annex): static
2142.     {
2143.         $this->annex = $annex;
2145.         return $this;
2146.     }
2148.     public function getTerminationDate(): ?\DateTimeInterface
2149.     {
2150.         return $this->terminationDate;
2151.     }
2153.     public function setTerminationDate(?\DateTimeInterface $terminationDate): static
2154.     {
2155.         $this->terminationDate = $terminationDate;
2157.         return $this;
2158.     }
2160.     public function isEffectivelyTerminated(): ?bool
2161.     {
2162.         return $this->effectivelyTerminated;
2163.     }
2165.     public function setEffectivelyTerminated(bool $effectivelyTerminated): static
2166.     {
2167.         $this->effectivelyTerminated = $effectivelyTerminated;
2169.         return $this;
2170.     }
2172.     public function getRootOrder(): ?self
2173.     {
2174.         $order = $this->getParentOrder();
2176.         if ($order === null) {
2177.             return null;
2178.         }
2180.         while ($order->getParentOrder() !== null) {
2181.             $order = $order->getParentOrder();
2182.         }
2184.         return $order;
2185.     }
2187.     public function getContractStartDate(): ?\DateTimeInterface
2188.     {
2189.         return $this->contractStartDate;
2190.     }
2192.     public function setContractStartDate(?\DateTimeInterface $contractStartDate): static
2193.     {
2194.         $this->contractStartDate = $contractStartDate;
2196.         return $this;
2197.     }
2199.     public function getOrderReminders(): Collection
2200.     {
2201.         return $this->orderReminders;
2202.     }
2204.     public function setOrderReminders(Collection $orderReminders): void
2205.     {
2206.         $this->orderReminders = $orderReminders;
2207.     }
2209.     /**
2210.      * @return Collection<int, OrderLicence>
2211.      */
2212.     public function getOrderLicense(): Collection
2213.     {
2214.         return $this->orderLicense;
2215.     }
2217.     public function addOrderLicense(OrderLicence $orderLicense): static
2218.     {
2219.         if (!$this->orderLicense->contains($orderLicense)) {
2220.             $this->orderLicense->add($orderLicense);
2221.             $orderLicense->setOrderInstance($this);
2222.         }
2224.         return $this;
2225.     }
2227.     public function removeOrderLicense(OrderLicence $orderLicense): static
2228.     {
2229.         if ($this->orderLicense->removeElement($orderLicense)) {
2230.             // set the owning side to null (unless already changed)
2231.             if ($orderLicense->getOrderInstance() === $this) {
2232.                 $orderLicense->setOrderInstance(null);
2233.             }
2234.         }
2236.         return $this;
2237.     }
2239.     public function getAneksToken(): ?string
2240.     {
2241.         return $this->aneksToken;
2242.     }
2244.     public function setAneksToken(?string $aneksToken): void
2245.     {
2246.         $this->aneksToken = $aneksToken;
2247.     }
2249.     public function getTokenKontrolaZarzadczaJst(): ?string
2250.     {
2251.         return $this->tokenKontrolaZarzadczaJst;
2252.     }
2254.     public function setTokenKontrolaZarzadczaJst(?string $tokenKontrolaZarzadczaJst): void
2255.     {
2256.         $this->tokenKontrolaZarzadczaJst = $tokenKontrolaZarzadczaJst;
2257.     }
2259.     public function getAneksOrder(): ?self
2260.     {
2261.         return $this->aneksOrder;
2262.     }
2264.     public function setAneksOrder(?self $aneksOrder): static
2265.     {
2266.         $this->aneksOrder = $aneksOrder;
2268.         return $this;
2269.     }
2271.     /**
2272.      * @return Collection<int, self>
2273.      */
2274.     public function getAneksOrders(): Collection
2275.     {
2276.         return $this->aneksOrders;
2277.     }
2279.     public function addAneksOrder(self $aneksOrder): static
2280.     {
2281.         if (!$this->aneksOrders->contains($aneksOrder)) {
2282.             $this->aneksOrders->add($aneksOrder);
2283.             $aneksOrder->setAneksOrder($this);
2284.         }
2286.         return $this;
2287.     }
2289.     public function removeAneksOrder(self $aneksOrder): static
2290.     {
2291.         if ($this->aneksOrders->removeElement($aneksOrder)) {
2292.             // set the owning side to null (unless already changed)
2293.             if ($aneksOrder->getAneksOrder() === $this) {
2294.                 $aneksOrder->setAneksOrder(null);
2295.             }
2296.         }
2298.         return $this;
2299.     }
2300. }