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]
50.     private ?bool $optimaInvoiceAdded = false;
52.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
53.     private ?DateTimeInterface $optimaInvoiceAddedAt = null;
55.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
56.     private ?DateTimeInterface $paymentDate = null;
58.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
59.     private ?DateTimeInterface $dateOfPayment = null;
61.     #[ORM\Column]
62.     private ?bool $ended = false;
64.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
65.     private ?DateTimeInterface $contractExpirationDate = null;
67.     #[ORM\Column]
68.     private ?bool $fixedTerm = false;
70.     #[ORM\Column]
71.     private ?bool $contractEnded = false;
73.     #[ORM\Column(length: 255, nullable: true)]
74.     private ?string $contractNumber = null;
76.     #[ORM\Column]
77.     private ?bool $checked = false;
79.     #[ORM\Column]
80.     private ?bool $firstOrder = false;
82.     #[ORM\ManyToMany(targetEntity: Implementer::class, inversedBy: 'orders')]
83.     private Collection $implementer;
85.     #[ORM\Column(length: 255, nullable: true)]
86.     private ?string $inspector = null;
88.     #[ORM\Column]
89.     private ?bool $implementationCompleted = false;
91.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
92.     private ?DateTimeInterface $implementationCompletedDate = null;
94.     #[ORM\ManyToOne(targetEntity: self::class)]
95.     private ?self $parentOrder = null;
97.     #[ORM\Column]
98.     private ?bool $contractExtended = false;
100.     #[ORM\Column]
101.     private ?bool $firstContract = false;
103.     #[ORM\Column]
104.     private ?bool $contractSigned = false;
106.     #[ORM\Column(length: 255, nullable: true)]
107.     private ?string $token = null;
109.     #[ORM\Column]
110.     private ?bool $automaticallyExtended = false;
112.     #[ORM\Column(length: 255, nullable: true)]
113.     private ?string $tokenOffice = null;
115.     #[ORM\Column(nullable: true)]
116.     private ?int $recommendedNumber = null;
118.     #[ORM\Column(length: 255, nullable: true)]
119.     private ?string $officeInvoice = null;
121.     #[ORM\Column(nullable: true)]
122.     private ?int $commissionPercentage = null;
124.     #[ORM\Column(nullable: true)]
125.     private ?int $activationAmmount = null;
127.     #[ORM\Column]
128.     private ?bool $officeContractEnded = false;
130.     #[ORM\Column(nullable: true)]
131.     private ?int $bhpPackage = null;
133.     #[ORM\Column(length: 255, nullable: true)]
134.     private ?string $tokenBhpRodo = null;
136.     #[ORM\Column(nullable: true)]
137.     private ?int $reward = null;
139.     #[ORM\Column(length: 255, nullable: true)]
140.     private ?string $tokenIod = null;
142.     #[ORM\Column(length: 255, nullable: true)]
143.     private ?string $tokenBdo = null;
145.     #[ORM\Column(length: 255, nullable: true)]
146.     private ?string $tokenBhpStationary = null;
148.     #[ORM\Column]
149.     private ?bool $auditReady = false;
151.     #[ORM\Column]
152.     private ?bool $auditEnded = false;
154.     #[ORM\Column]
155.     private ?bool $contractWithoutCourses = false;
157.     public float $priceTotal = 0;
159.     public float $priceSubtotal = 0;
161.     public array $prices = [];
163.     public string $firstOrderString = '';
165.     #[ORM\OneToMany(mappedBy: 'orderId', targetEntity: OrderHistory::class, orphanRemoval: true)]
166.     private Collection $orderHistories;
168.     #[ORM\ManyToOne(inversedBy: 'orders')]
169.     #[ORM\JoinColumn(nullable: false)]
170.     private ?Customer $customer = null;
172.     #[ORM\ManyToOne(inversedBy: 'orders')]
173.     #[ORM\JoinColumn(nullable: true)]
174.     private ?CustomerAddress $customerAddress = null;
176.     #[ORM\OneToMany(mappedBy: 'orderId', targetEntity: OrderProduct::class, cascade: ['persist'], orphanRemoval: true,)]
177.     private Collection $orderProduct;
179.     #[ORM\ManyToOne(inversedBy: 'orders')]
180.     #[ORM\JoinColumn(nullable: false)]
181.     private ?Branch $branch = null;
183.     #[ORM\OneToOne(inversedBy: 'orderInstance', cascade: ['persist', 'remove'])]
184.     private ?Contract $contract = null;
186.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: Instalments::class, cascade: ['persist', 'remove'])]
187.     private Collection $instalments;
189.     #[ORM\Column]
190.     private ?bool $instalment = false;
192.     #[ORM\OneToOne(inversedBy: 'orderInst', cascade: ['persist', 'remove'])]
193.     private ?ContractIndividual $contractIndividual = null;
195.     #[ORM\Column(nullable: true)]
196.     private ?bool $needContract = null;
198.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: OrderNote::class)]
199.     private Collection $orderNotes;
201.     #[ORM\ManyToOne(inversedBy: 'dividedOrders')]
202.     private ?Consultant $orderDividedConsultant = null;
203.     #[ORM\OneToMany(mappedBy: 'orderId', targetEntity: ImplementerOrderHistory::class)]
204.     private Collection $implementerOrderHistories;
206.     #[ORM\OneToOne(mappedBy: 'orderId', cascade: ['persist', 'remove'])]
207.     private ?ImplementerOrderData $implementerOrderData = null;
209.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: BhpOrderProduct::class)]
210.     private Collection $BhpOrderProducts;
212.     #[ORM\ManyToOne(inversedBy: 'orders')]
213.     private ?Admin $admin = null;
215.     #[ORM\Column]
216.     private bool $doBeforePayment = false;
218.     #[ORM\Column(nullable: true)]
219.     private ?int $oldOrderId = null;
221.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: AccountingOfficeCategory::class)]
222.     private Collection $accountingOfficeCategories;
224.     #[ORM\OneToMany(mappedBy: 'OrderInstance', targetEntity: BhpJournals::class)]
225.     private Collection $bhpJournals;
227.     #[ORM\Column(length: 255, nullable: true)]
228.     private ?string $tokenAml = null;
230.     #[ORM\Column(length: 255, nullable: true)]
231.     private ?string $tokenAmlrodo = null;
233.     #[ORM\ManyToOne(inversedBy: 'orders')]
234.     private ?DebtStatus $debtStatus = null;
236.     #[ORM\Column]
237.     private ?bool $debtCollection = null;
239.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
240.     private ?\DateTimeInterface $debtContactDate = null;
242.     #[ORM\OneToMany(mappedBy: 'orderId', targetEntity: DebtNote::class)]
243.     private Collection $debtNotes;
245.     #[ORM\Column(type: Types::TEXT, nullable: true)]
246.     private ?string $littleNote = null;
248.     #[ORM\OneToOne(mappedBy: 'orderId', cascade: ['persist', 'remove'])]
249.     private ?OrderCustomer $orderCustomer = null;
251.     #[ORM\OneToOne(mappedBy: 'orderId', cascade: ['persist', 'remove'])]
252.     private ?OrderCustomerAddress $orderCustomerAddress = null;
254.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
255.     private ?\DateTimeInterface $contractSignedDate = null;
258.     #[ORM\OneToMany(mappedBy: 'orderId', targetEntity: OrderDivided::class, orphanRemoval: true)]
259.     private Collection $orderDivideds;
261.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: MailHistory::class)]
262.     private Collection $mailHistories;
264.     #[ORM\Column]
265.     private ?bool $haveInstalments = false;
267.     #[ORM\ManyToOne(inversedBy: 'extensionOrders')]
268.     private ?OrderNote $orderNoteForExtension = null;
270.     #[ORM\Column]
271.     private bool $implementationCompletedWithoutAudit = false;
273.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
274.     private ?\DateTimeInterface $debtStatusChangeDate = null;
276.     #[ORM\ManyToMany(targetEntity: Consultant::class, inversedBy: 'ordersToNotes')]
277.     private Collection $consultantForNotes;
279.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: Task::class)]
280.     private Collection $tasks;
282.     #[ORM\OneToMany(mappedBy: 'orderId', targetEntity: SmsHistory::class)]
283.     private Collection $smsHistories;
285.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
286.     private ?\DateTimeInterface $noticeDate = null;
288.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: SurveyResponse::class)]
289.     private Collection $surveyResponses;
291.     #[ORM\OneToMany(mappedBy: 'orderInstance', targetEntity: ZoomList::class)]
292.     private Collection $zoomLists;
294.     #[ORM\Column(length: 255, nullable: true)]
295.     private ?string $tokenLicencyjnaWebAml = null;
297.     #[ORM\Column(length: 255, nullable: true)]
298.     private ?string $tokenLicencyjnaWebAmlPartnerska = null;
300.     #[ORM\Column(length: 255, nullable: true)]
301.     private ?string $tokenLicencyjnaWebAmlNieruchomosci = null;
303.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
304.     private ?\DateTimeInterface $dateForPoints = null;
306.     #[ORM\Column]
307.     private ?bool $pointsAdded = null;
309.     #[ORM\Column]
310.     private ?bool $forCountingSprawozdaniaOther = null;
312.     #[ORM\Column]
313.     private ?bool $annex = null;
315.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
316.     private ?\DateTimeInterface $terminationDate = null;
318.     #[ORM\Column]
319.     private ?bool $effectivelyTerminated = null;
321.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
322.     private ?\DateTimeInterface $contractStartDate = null;
324.     public function __construct()
325.     {
326.         $this->addedDate = new DateTime();
327.         $this->updateDate = new DateTime();
328.         $this->implementer = new ArrayCollection();
329.         $this->orderHistories = new ArrayCollection();
330.         $this->orderProduct = new ArrayCollection();
331.         $this->instalments = new ArrayCollection();
332.         $this->orderNotes = new ArrayCollection();
333.         $this->implementerOrderHistories = new ArrayCollection();
334.         $this->BhpOrderProducts = new ArrayCollection();
335.         $this->accountingOfficeCategories = new ArrayCollection();
336.         $this->bhpJournals = new ArrayCollection();
337.         $this->debtNotes = new ArrayCollection();
338.         $this->orderDivideds = new ArrayCollection();
339.         $this->mailHistories = new ArrayCollection();
340.         $this->orderNoteForExtension = NULL;
341.         $this->consultantForNotes = new ArrayCollection();
342.         $this->tasks = new ArrayCollection();
343.         $this->smsHistories = new ArrayCollection();
344.         $this->noticeDate = NULL;
345.         $this->surveyResponses = new ArrayCollection();
346.         $this->zoomLists = new ArrayCollection();
347.         $this->pointsAdded = false;
348.         $this->dateForPoints = NULL;
349.         $this->forCountingSprawozdaniaOther = false;
350.         $this->annex = false;
351.         $this->terminationDate = NULL;
352.         $this->effectivelyTerminated = false;
353.     }
355.     public function __toString(): string
356.     {
357.         return $this->getId();
358.     }
360.     public function getId(): ?int
361.     {
362.         return $this->id;
363.     }
365.     public function getOrderSubTotal(): float
366.     {
367.         $products = $this->getOrderProduct();
368.         $sum = 0;
369.         foreach ($this->getOrderProduct() as $product) {
370.             $sum = $sum+$product->getPriceSubtotal();
371.         }
372.         return $sum;
373.     }
375.     public function getOrderTotal(): float
376.     {
377.         $products = $this->getOrderProduct();
378.         $sum = 0;
379.         foreach ($this->getOrderProduct() as $product) {
380.             $sum = +$product->getPriceTotal();
381.         }
382.         return $sum;
383.     }
385.     public function getOrderStatus(): ?OrderStatus
386.     {
387.         return $this->orderStatus;
388.     }
390.     public function setOrderStatus(?OrderStatus $orderStatus): self
391.     {
392.         $this->orderStatus = $orderStatus;
394.         return $this;
395.     }
397.     public function getAddedDate(): DateTimeInterface
398.     {
399.         return $this->addedDate;
400.     }
403.     public function getUpdateDate(): ?DateTimeInterface
404.     {
405.         return $this->updateDate;
406.     }
408.     public function setUpdateDate(?DateTimeInterface $updateDate): self
409.     {
410.         $this->updateDate = $updateDate;
412.         return $this;
413.     }
415.     public function getShipping(): ?Shipping
416.     {
417.         return $this->shipping;
418.     }
420.     public function setShipping(?Shipping $shipping): self
421.     {
422.         $this->shipping = $shipping;
424.         return $this;
425.     }
427.     public function getConsultant(): ?Consultant
428.     {
429.         return $this->consultant;
430.     }
432.     public function setConsultant(?Consultant $consultant): self
433.     {
434.         $this->consultant = $consultant;
436.         return $this;
437.     }
439.     public function getAdministrationFee(): ?int
440.     {
441.         $adFeeSum = 0;
442.         foreach($this->orderProduct as $op){
443.             $adFeeSum += $op->getAdministrationFee();
444.         }
446.         return $adFeeSum;
447.     }
449.     public function setAdministrationFee(int $administrationFee): self
450.     {
451.         $this->administrationFee = $administrationFee;
453.         return $this;
454.     }
456.     public function getRanking(): ?int
457.     {
458.         return $this->ranking;
459.     }
461.     public function setRanking(?int $ranking): self
462.     {
463.         $this->ranking = $ranking;
465.         return $this;
466.     }
468.     public function getInvoiceNumber(): ?string
469.     {
470.         return $this->invoiceNumber;
471.     }
473.     public function setInvoiceNumber(?string $invoiceNumber): self
474.     {
475.         $this->invoiceNumber = $invoiceNumber;
477.         return $this;
478.     }
480.     public function isOptimaInvoiceAdded(): ?bool
481.     {
482.         return $this->optimaInvoiceAdded;
483.     }
485.     public function setOptimaInvoiceAdded(bool $optimaInvoiceAdded): static
486.     {
487.         $this->optimaInvoiceAdded = $optimaInvoiceAdded;
489.         return $this;
490.     }
492.     public function getOptimaInvoiceAddedAt(): ?DateTimeInterface
493.     {
494.         return $this->optimaInvoiceAddedAt;
495.     }
497.     public function setOptimaInvoiceAddedAt(?DateTimeInterface $optimaInvoiceAddedAt): static
498.     {
499.         $this->optimaInvoiceAddedAt = $optimaInvoiceAddedAt;
501.         return $this;
502.     }
504.     public function getPaymentDate(): ?DateTimeInterface
505.     {
506.         return $this->paymentDate;
507.     }
509.     public function setPaymentDate(?DateTimeInterface $paymentDate): self
510.     {
511.         $this->paymentDate = $paymentDate;
513.         return $this;
514.     }
516.     public function getDateOfPayment(): ?DateTimeInterface
517.     {
518.         return $this->dateOfPayment;
519.     }
521.     public function setDateOfPayment(?DateTimeInterface $dateOfPayment): self
522.     {
523.         $this->dateOfPayment = $dateOfPayment;
525.         return $this;
526.     }
528.     public function isEnded(): ?bool
529.     {
530.         return $this->ended;
531.     }
533.     public function setEnded(bool $ended): self
534.     {
535.         $this->ended = $ended;
537.         return $this;
538.     }
540.     public function getContractExpirationDate(): ?DateTimeInterface
541.     {
542.         return $this->contractExpirationDate;
543.     }
545.     public function setContractExpirationDate(?DateTimeInterface $contractExpirationDate): self
546.     {
547.         $this->contractExpirationDate = $contractExpirationDate;
549.         return $this;
550.     }
552.     public function isFixedTerm(): ?bool
553.     {
554.         return $this->fixedTerm;
555.     }
557.     public function setFixedTerm(bool $fixedTerm): self
558.     {
559.         $this->fixedTerm = $fixedTerm;
561.         return $this;
562.     }
564.     public function isContractEnded(): ?bool
565.     {
566.         return $this->contractEnded;
567.     }
569.     public function setContractEnded(bool $contractEnded): self
570.     {
571.         $this->contractEnded = $contractEnded;
573.         return $this;
574.     }
576.     public function getContractNumber(): ?string
577.     {
578.         return $this->contractNumber;
579.     }
581.     public function setContractNumber(?string $contractNumber): self
582.     {
583.         $this->contractNumber = $contractNumber;
585.         return $this;
586.     }
588.     public function isChecked(): ?bool
589.     {
590.         return $this->checked;
591.     }
593.     public function setChecked(bool $checked): self
594.     {
595.         $this->checked = $checked;
597.         return $this;
598.     }
600.     public function isFirstOrder(): ?bool
601.     {
602.         return $this->firstOrder;
603.     }
605.     public function setFirstOrder(bool $firstOrder): self
606.     {
607.         $this->firstOrder = $firstOrder;
609.         return $this;
610.     }
612.     public function getImplementer(): Collection
613.     {
614.         return $this->implementer;
615.     }
617.     public function addImplementer(Implementer $implementer): self
618.     {
619.         if (!$this->implementer->contains($implementer)) {
620.             $this->implementer->add($implementer);
621.         }
623.         return $this;
624.     }
626.     public function removeImplementer(Implementer $implementer): self
627.     {
628.         $this->implementer->removeElement($implementer);
630.         return $this;
631.     }
633.     public function getAllImplementers(): array
634.     {
635.         $implementers = [];
636.         $orderProducts = $this->getOrderProduct();
637.         foreach ($orderProducts as $orderProduct) {
638.             $implementersOrderProducts = $orderProduct->getImplementerOrderProducts();
639.             foreach ($implementersOrderProducts as $implementersOrderProduct) {
640.                 if(count($implementersOrderProduct->getProduct()->getChildProducts())===0) {
641.                     $iopImplementers = $implementersOrderProduct->getImplementer();
642.                     foreach ($iopImplementers as $iopImplementer) {
643.                         if (!in_array($iopImplementer, $implementers)) {
644.                             $implementers[] = $iopImplementer;
645.                         }
646.                     }
647.                 }
648.             }
649.         }
651.         return $implementers;
652.     }
654.     public function getAllImplementersForNotCompletedAndNotNeeded(): array
655.     {
656.         $implementers = [];
657.         $orderProducts = $this->getOrderProduct();
658.         foreach ($orderProducts as $orderProduct) {
659.             $implementersOrderProducts = $orderProduct->getImplementerOrderProducts();
660.             foreach ($implementersOrderProducts as $implementersOrderProduct) {
661.                 $status = $implementersOrderProduct->getStatus();
662.                 if ($status === null || (!$status->isEnding() && !$status->isNotNeeded())) {
663.                     if(count($implementersOrderProduct->getProduct()->getChildProducts())===0) {
664.                         $iopImplementers = $implementersOrderProduct->getImplementer();
665.                         foreach ($iopImplementers as $iopImplementer) {
666.                             if (!in_array($iopImplementer, $implementers)) {
667.                                 $implementers[] = $iopImplementer;
668.                             }
669.                         }
670.                     }
671.                 }
672.             }
673.         }
675.         return $implementers;
676.     }
678.     public function getInspector(): ?string
679.     {
680.         return $this->inspector;
681.     }
683.     public function setInspector(?string $inspector): self
684.     {
685.         $this->inspector = $inspector;
687.         return $this;
688.     }
690.     public function isImplementationCompleted(): ?bool
691.     {
692.         return $this->implementationCompleted;
693.     }
695.     public function setImplementationCompleted(bool $implementationCompleted): self
696.     {
697.         $this->implementationCompleted = $implementationCompleted;
699.         return $this;
700.     }
702.     public function getImplementationCompletedDate(): ?DateTimeInterface
703.     {
704.         return $this->implementationCompletedDate;
705.     }
707.     public function setImplementationCompletedDate(?DateTimeInterface $implementationCompletedDate): self
708.     {
709.         $this->implementationCompletedDate = $implementationCompletedDate;
711.         return $this;
712.     }
714.     public function getParentOrder(): ?self
715.     {
716.         return $this->parentOrder;
717.     }
719.     public function setParentOrder(?self $parentOrder): self
720.     {
721.         $this->parentOrder = $parentOrder;
723.         return $this;
724.     }
726.     public function isContractExtended(): ?bool
727.     {
728.         return $this->contractExtended;
729.     }
731.     public function setContractExtended(bool $contractExtended): self
732.     {
733.         $this->contractExtended = $contractExtended;
735.         return $this;
736.     }
738.     public function isFirstContract(): ?bool
739.     {
740.         return $this->firstContract;
741.     }
743.     public function setFirstContract(bool $firstContract): self
744.     {
745.         $this->firstContract = $firstContract;
747.         return $this;
748.     }
750.     public function isContractSigned(): ?bool
751.     {
752.         return $this->contractSigned;
753.     }
755.     public function setContractSigned(bool $contractSigned): self
756.     {
757.         $this->contractSigned = $contractSigned;
759.         return $this;
760.     }
762.     public function getToken(): ?string
763.     {
764.         return $this->token;
765.     }
767.     public function setToken(?string $token): self
768.     {
769.         $this->token = $token;
771.         return $this;
772.     }
774.     public function isAutomaticallyExtended(): ?bool
775.     {
776.         return $this->automaticallyExtended;
777.     }
779.     public function setAutomaticallyExtended(bool $automaticallyExtended): self
780.     {
781.         $this->automaticallyExtended = $automaticallyExtended;
782.         ($automaticallyExtended)?$this->setNoticeDate(NULL):$this->setNoticeDate(new DateTime());
784.         return $this;
785.     }
787.     public function getTokenOffice(): ?string
788.     {
789.         return $this->tokenOffice;
790.     }
792.     public function setTokenOffice(?string $tokenOffice): self
793.     {
794.         $this->tokenOffice = $tokenOffice;
796.         return $this;
797.     }
799.     public function getRecommendedNumber(): ?int
800.     {
801.         return $this->recommendedNumber;
802.     }
804.     public function setRecommendedNumber(?int $recommendedNumber): self
805.     {
806.         $this->recommendedNumber = $recommendedNumber;
808.         return $this;
809.     }
811.     public function getOfficeInvoice(): ?string
812.     {
813.         return $this->officeInvoice;
814.     }
816.     public function setOfficeInvoice(?string $officeInvoice): self
817.     {
818.         $this->officeInvoice = $officeInvoice;
820.         return $this;
821.     }
823.     public function getCommissionPercentage(): ?int
824.     {
825.         return $this->commissionPercentage;
826.     }
828.     public function setCommissionPercentage(?int $commissionPercentage): self
829.     {
830.         $this->commissionPercentage = $commissionPercentage;
832.         return $this;
833.     }
835.     public function getActivationAmmount(): ?int
836.     {
837.         return $this->activationAmmount;
838.     }
840.     public function setActivationAmmount(?int $activationAmmount): self
841.     {
842.         $this->activationAmmount = $activationAmmount;
844.         return $this;
845.     }
847.     public function isOfficeContractEnded(): ?bool
848.     {
849.         return $this->officeContractEnded;
850.     }
852.     public function setOfficeContractEnded(bool $officeContractEnded): self
853.     {
854.         $this->officeContractEnded = $officeContractEnded;
856.         return $this;
857.     }
859.     public function getBhpPackage(): ?int
860.     {
861.         return $this->bhpPackage;
862.     }
864.     public function setBhpPackage(int $bhpPackage): self
865.     {
866.         $this->bhpPackage = $bhpPackage;
868.         return $this;
869.     }
871.     public function getTokenBhpRodo(): ?string
872.     {
873.         return $this->tokenBhpRodo;
874.     }
876.     public function setTokenBhpRodo(?string $tokenBhpRodo): self
877.     {
878.         $this->tokenBhpRodo = $tokenBhpRodo;
880.         return $this;
881.     }
883.     public function getReward(): ?int
884.     {
885.         return $this->reward;
886.     }
888.     public function setReward(?int $reward): self
889.     {
890.         $this->reward = $reward;
892.         return $this;
893.     }
895.     public function getTokenIod(): ?string
896.     {
897.         return $this->tokenIod;
898.     }
900.     public function setTokenIod(?string $tokenIod): self
901.     {
902.         $this->tokenIod = $tokenIod;
904.         return $this;
905.     }
907.     public function getTokenBdo(): ?string
908.     {
909.         return $this->tokenBdo;
910.     }
912.     public function setTokenBdo(?string $tokenBdo): self
913.     {
914.         $this->tokenBdo = $tokenBdo;
916.         return $this;
917.     }
919.     public function getTokenBhpStationary(): ?string
920.     {
921.         return $this->tokenBhpStationary;
922.     }
924.     public function setTokenBhpStationary(?string $tokenBhpStationary): self
925.     {
926.         $this->tokenBhpStationary = $tokenBhpStationary;
928.         return $this;
929.     }
931.     public function isAuditReady(): ?bool
932.     {
933.         return $this->auditReady;
934.     }
936.     public function setAuditReady(bool $auditReady): self
937.     {
938.         $this->auditReady = $auditReady;
940.         return $this;
941.     }
943.     public function isAuditEnded(): ?bool
944.     {
945.         return $this->auditEnded;
946.     }
948.     public function setAuditEnded(bool $auditEnded): self
949.     {
950.         $this->auditEnded = $auditEnded;
952.         return $this;
953.     }
955.     public function isContractWithoutCourses(): ?bool
956.     {
957.         return $this->contractWithoutCourses;
958.     }
960.     public function setContractWithoutCourses(bool $contractWithoutCourses): self
961.     {
962.         $this->contractWithoutCourses = $contractWithoutCourses;
964.         return $this;
965.     }
967.     public function getOrderHistories(): Collection
968.     {
969.         return $this->orderHistories;
970.     }
972.     public function addOrderHistory(OrderHistory $orderHistory): self
973.     {
974.         if (!$this->orderHistories->contains($orderHistory)) {
975.             $this->orderHistories->add($orderHistory);
976.             $orderHistory->setOrderId($this);
977.         }
979.         return $this;
980.     }
982.     public function removeOrderHistory(OrderHistory $orderHistory): self
983.     {
984.         if ($this->orderHistories->removeElement($orderHistory)) {
985.             if ($orderHistory->getOrderId() === $this) {
986.                 $orderHistory->setOrderId(null);
987.             }
988.         }
990.         return $this;
991.     }
993.     public function getCustomer(): ?Customer
994.     {
995.         return $this->customer;
996.     }
998.     public function setCustomer(?Customer $customer): self
999.     {
1000.         $this->customer = $customer;
1002.         return $this;
1003.     }
1005.     public function getCustomerAddress(): ?CustomerAddress
1006.     {
1007.         return $this->customerAddress;
1008.     }
1010.     public function setCustomerAddress(?CustomerAddress $customerAddress): self
1011.     {
1012.         $this->customerAddress = $customerAddress;
1014.         return $this;
1015.     }
1017.     public function getOrderProduct(): Collection
1018.     {
1019.         return $this->orderProduct;
1020.     }
1022.     public function addOrderProduct(OrderProduct $orderProduct): self
1023.     {
1024.         if (!$this->orderProduct->contains($orderProduct)) {
1025.             $this->orderProduct->add($orderProduct);
1026.             $orderProduct->setOrderId($this);
1027.         }
1029.         return $this;
1030.     }
1032.     public function removeOrderProduct(OrderProduct $orderProduct): self
1033.     {
1034.         if ($this->orderProduct->removeElement($orderProduct)) {
1035.             if ($orderProduct->getOrderId() === $this) {
1036.                 $orderProduct->setOrderId(null);
1037.             }
1038.         }
1040.         return $this;
1041.     }
1043.     public function getPriceTotal(): float
1044.     {
1045.         $sum = 0;
1046.         $products = $this->getOrderProduct();
1047.         foreach ($products as $product) {
1048.             $sum = $sum + (($product->getPriceSubtotal() * $product->getQuantity()) * (1 + ($product->getProduct()->getTax() / 100)));
1049.         }
1051.         return $this->ceiling($sum,2);
1052.     }
1054.     function ceiling($value, int $precision = 0) {
1055.         $offset = 0.5;
1056.         if ($precision !== 0)
1057.             $offset /= pow(10, $precision);
1058.         $final = round($value + $offset, $precision, PHP_ROUND_HALF_DOWN);
1059.         return ($final == -0 ? 0 : $final);
1060.     }
1062.     public function getPriceSubtotal(): float
1063.     {
1064.         $sum = 0;
1065.         $products = $this->getOrderProduct();
1066.         foreach ($products as $product) {
1067.             $sum = $sum + ($product->getPriceSubtotal() * $product->getQuantity());
1068.         }
1070.         return $sum;
1071.     }
1073.     public function getPrices(): array
1074.     {
1075.         return [
1076.             'subtotal' => number_format($this->getPriceSubtotal(), 2),
1077.             'total' => number_format($this->getPriceTotal(), 2),
1078.         ];
1079.     }
1081.     public function getFirstOrderString(): string
1082.     {
1083.         return $this->isFirstOrder();
1084.     }
1086.     public function getBranch(): ?Branch
1087.     {
1088.         return $this->branch;
1089.     }
1091.     public function setBranch(?Branch $branch): static
1092.     {
1093.         $this->branch = $branch;
1095.         return $this;
1096.     }
1098.     public function getContract(): ?Contract
1099.     {
1100.         return $this->contract;
1101.     }
1103.     public function setContract(?Contract $contract): static
1104.     {
1105.         $this->contract = $contract;
1107.         return $this;
1108.     }
1110.     /**
1111.      * @return Collection<int, Instalments>
1112.      */
1113.     public function getInstalments(): Collection
1114.     {
1115.         return $this->instalments;
1116.     }
1118.     public function addInstalment(Instalments $instalment): static
1119.     {
1120.         if (!$this->instalments->contains($instalment)) {
1121.             $this->instalments->add($instalment);
1122.             $instalment->setOrderInstance($this);
1123.         }
1125.         return $this;
1126.     }
1128.     public function removeInstalment(Instalments $instalment): static
1129.     {
1130.         if ($this->instalments->removeElement($instalment)) {
1131.             // set the owning side to null (unless already changed)
1132.             if ($instalment->getOrderInstance() === $this) {
1133.                 $instalment->setOrderInstance(null);
1134.             }
1135.         }
1137.         return $this;
1138.     }
1140.     public function isInstalment(): ?bool
1141.     {
1142.         return $this->instalment;
1143.     }
1145.     public function setInstalment(bool $instalment): static
1146.     {
1147.         $this->instalment = $instalment;
1149.         return $this;
1150.     }
1152.     public function getContractIndividual(): ?ContractIndividual
1153.     {
1154.         return $this->contractIndividual;
1155.     }
1157.     public function setContractIndividual(?ContractIndividual $contractIndividual): static
1158.     {
1159.         $this->contractIndividual = $contractIndividual;
1161.         return $this;
1162.     }
1164.     public function isNeedContract(): ?bool
1165.     {
1166.         return $this->needContract;
1167.     }
1169.     public function setNeedContract(?bool $needContract): static
1170.     {
1171.         $this->needContract = $needContract;
1173.         return $this;
1174.     }
1176.     /**
1177.      * @return Collection<int, ImplementerOrderHistory>
1178.      */
1179.     public function getImplementerOrderHistories(): Collection
1180.     {
1181.         return $this->implementerOrderHistories;
1182.     }
1184.     public function addImplementerOrderHistory(ImplementerOrderHistory $implementerOrderHistory): static
1185.     {
1186.         if (!$this->implementerOrderHistories->contains($implementerOrderHistory)) {
1187.             $this->implementerOrderHistories->add($implementerOrderHistory);
1188.             $implementerOrderHistory->setOrderId($this);
1189.         }
1191.         return $this;
1192.     }
1194.     public function removeImplementerOrderHistory(ImplementerOrderHistory $implementerOrderHistory): static
1195.     {
1196.         if ($this->implementerOrderHistories->removeElement($implementerOrderHistory)) {
1197.             // set the owning side to null (unless already changed)
1198.             if ($implementerOrderHistory->getOrderId() === $this) {
1199.                 $implementerOrderHistory->setOrderId(null);
1200.             }
1201.         }
1203.         return $this;
1204.     }
1206.     public function getImplementerOrderData(): ?ImplementerOrderData
1207.     {
1208.         return $this->implementerOrderData;
1209.     }
1211.     public function setImplementerOrderData(ImplementerOrderData $implementerOrderData): static
1212.     {
1213.         // set the owning side of the relation if necessary
1214.         if ($implementerOrderData->getOrderId() !== $this) {
1215.             $implementerOrderData->setOrderId($this);
1216.         }
1218.         $this->implementerOrderData = $implementerOrderData;
1220.         return $this;
1221.     }
1223.     /**
1224.      * @return Collection<int, OrderNote>
1225.      */
1226.     public function getOrderNotes(): Collection
1227.     {
1228.         return $this->orderNotes;
1229.     }
1231.     public function addOrderNote(OrderNote $orderNote): static
1232.     {
1233.         if (!$this->orderNotes->contains($orderNote)) {
1234.             $this->orderNotes->add($orderNote);
1235.             $orderNote->setOrderInstance($this);
1236.         }
1238.         return $this;
1239.     }
1241.     public function removeOrderNote(OrderNote $orderNote): static
1242.     {
1243.         if ($this->orderNotes->removeElement($orderNote)) {
1244.             // set the owning side to null (unless already changed)
1245.             if ($orderNote->getOrderInstance() === $this) {
1246.                 $orderNote->setOrderInstance(null);
1247.             }
1248.         }
1250.         return $this;
1251.     }
1253.     public function getOrderDividedConsultant(): ?Consultant
1254.     {
1255.         return $this->orderDividedConsultant;
1256.     }
1258.     public function setOrderDividedConsultant(?Consultant $orderDividedConsultant): static
1259.     {
1260.         $this->orderDividedConsultant = $orderDividedConsultant;
1262.         return $this;
1263.     }
1265.     /**
1266.      * @return Collection<int, BhpOrderProduct>
1267.      */
1268.     public function getBhpOrderProducts(): Collection
1269.     {
1270.         return $this->BhpOrderProducts;
1271.     }
1273.     public function addBhpOrderProduct(BhpOrderProduct $BhpOrderProduct): static
1274.     {
1275.         if (!$this->BhpOrderProducts->contains($BhpOrderProduct)) {
1276.             $this->BhpOrderProducts->add($BhpOrderProduct);
1277.             $BhpOrderProduct->setOrderInstance($this);
1278.         }
1280.         return $this;
1281.     }
1282.     public function getAdmin(): ?Admin
1283.     {
1284.         return $this->admin;
1285.     }
1287.     public function setAdmin(?Admin $admin): static
1288.     {
1289.         $this->admin = $admin;
1291.         return $this;
1292.     }
1294.     public function removeBhpOrderProduct(BhpOrderProduct $BhpOrderProduct): static
1295.     {
1296.         if ($this->BhpOrderProducts->removeElement($BhpOrderProduct)) {
1297.             // set the owning side to null (unless already changed)
1298.             if ($BhpOrderProduct->getOrderInstance() === $this) {
1299.                 $BhpOrderProduct->setOrderInstance(null);
1300.             }
1301.         }
1303.         return $this;
1304.     }
1306.     public function isDoBeforePayment(): ?bool
1307.     {
1308.         return $this->doBeforePayment;
1309.     }
1311.     public function setDoBeforePayment(bool $doBeforePayment): static
1312.     {
1313.         $this->doBeforePayment = $doBeforePayment;
1315.         return $this;
1316.     }
1318.     public function getOldOrderId(): ?int
1319.     {
1320.         return $this->oldOrderId;
1321.     }
1323.     public function setOldOrderId(?int $oldOrderId): static
1324.     {
1325.         $this->oldOrderId = $oldOrderId;
1327.         return $this;
1328.     }
1330.     public function getAdministrationFeeSum()
1331.     {
1332.         $orderProductAdministrationSum = 0;
1333.         foreach($this->orderProduct as $orderProduct){
1334.             $orderProductAdministrationSum += $orderProduct->getAdministrationFee();
1335.         }
1337.         return $orderProductAdministrationSum;
1338.     }
1340.     /**
1341.      * @return Collection<int, AccountingOfficeCategory>
1342.      */
1343.     public function getAccountingOfficeCategories(): Collection
1344.     {
1345.         return $this->accountingOfficeCategories;
1346.     }
1348.     public function addAccountingOfficeCategory(AccountingOfficeCategory $accountingOfficeCategory): static
1349.     {
1350.         if (!$this->accountingOfficeCategories->contains($accountingOfficeCategory)) {
1351.             $this->accountingOfficeCategories->add($accountingOfficeCategory);
1352.             $accountingOfficeCategory->setOrderInstance($this);
1353.         }
1355.         return $this;
1356.     }
1358.     public function removeAccountingOfficeCategory(AccountingOfficeCategory $accountingOfficeCategory): static
1359.     {
1360.         if ($this->accountingOfficeCategories->removeElement($accountingOfficeCategory)) {
1361.             // set the owning side to null (unless already changed)
1362.             if ($accountingOfficeCategory->getOrderInstance() === $this) {
1363.                 $accountingOfficeCategory->setOrderInstance(null);
1364.             }
1365.         }
1367.         return $this;
1368.     }
1370.     /**
1371.      * @return Collection<int, BhpJournals>
1372.      */
1373.     public function getBhpJournals(): Collection
1374.     {
1375.         return $this->bhpJournals;
1376.     }
1378.     public function addBhpJournal(BhpJournals $bhpJournal): static
1379.     {
1380.         if (!$this->bhpJournals->contains($bhpJournal)) {
1381.             $this->bhpJournals->add($bhpJournal);
1382.             $bhpJournal->setOrderInstance($this);
1383.         }
1385.         return $this;
1386.     }
1388.     public function removeBhpJournal(BhpJournals $bhpJournal): static
1389.     {
1390.         if ($this->bhpJournals->removeElement($bhpJournal)) {
1391.             // set the owning side to null (unless already changed)
1392.             if ($bhpJournal->getOrderInstance() === $this) {
1393.                 $bhpJournal->setOrderInstance(null);
1394.             }
1395.         }
1397.         return $this;
1398.     }
1400.     public function getTokenAml(): ?string
1401.     {
1402.         return $this->tokenAml;
1403.     }
1405.     public function setTokenAml(?string $tokenAml): static
1406.     {
1407.         $this->tokenAml = $tokenAml;
1409.         return $this;
1410.     }
1412.     public function getTokenAmlrodo(): ?string
1413.     {
1414.         return $this->tokenAmlrodo;
1415.     }
1417.     public function setTokenAmlrodo(?string $tokenAmlrodo): static
1418.     {
1419.         $this->tokenAmlrodo = $tokenAmlrodo;
1421.         return $this;
1422.     }
1424.     public function isWithUmowa():bool
1425.     {
1426.         $umowa = false;
1427.         foreach($this->getOrderProduct() as $orderProduct){
1428.             if($orderProduct->getProduct()->isUmowa()){
1429.                 $umowa = true;
1430.                 break;
1431.             }
1432.         }
1433.         return $umowa;
1434.     }
1436.     public function getDebtStatus(): ?DebtStatus
1437.     {
1438.         return $this->debtStatus;
1439.     }
1441.     public function setDebtStatus(?DebtStatus $debtStatus): static
1442.     {
1443.         $this->debtStatus = $debtStatus;
1445.         return $this;
1446.     }
1448.     public function isDebtCollection(): ?bool
1449.     {
1450.         return $this->debtCollection;
1451.     }
1453.     public function setDebtCollection(bool $debtCollection): static
1454.     {
1455.         $this->debtCollection = $debtCollection;
1457.         return $this;
1458.     }
1460.     public function getDebtContactDate(): ?\DateTimeInterface
1461.     {
1462.         return $this->debtContactDate;
1463.     }
1465.     public function setDebtContactDate(?\DateTimeInterface $debtContactDate): static
1466.     {
1467.         $this->debtContactDate = $debtContactDate;
1469.         return $this;
1470.     }
1472.     /**
1473.      * @return Collection<int, DebtNote>
1474.      */
1475.     public function getDebtNotes(): Collection
1476.     {
1477.         return $this->debtNotes;
1478.     }
1480.     public function addDebtNote(DebtNote $debtNote): static
1481.     {
1482.         if (!$this->debtNotes->contains($debtNote)) {
1483.             $this->debtNotes->add($debtNote);
1484.             $debtNote->setOrderId($this);
1485.         }
1487.         return $this;
1488.     }
1490.     public function removeDebtNote(DebtNote $debtNote): static
1491.     {
1492.         if ($this->debtNotes->removeElement($debtNote)) {
1493.             // set the owning side to null (unless already changed)
1494.             if ($debtNote->getOrderId() === $this) {
1495.                 $debtNote->setOrderId(null);
1496.             }
1497.         }
1499.         return $this;
1500.     }
1502.     public function getLittleNote(): ?string
1503.     {
1504.         return $this->littleNote;
1505.     }
1507.     public function setLittleNote(?string $littleNote): static
1508.     {
1509.         $this->littleNote = $littleNote;
1511.         return $this;
1512.     }
1514.     public function getOrderCustomer(): ?OrderCustomer
1515.     {
1516.         return $this->orderCustomer;
1517.     }
1519.     public function setOrderCustomer(OrderCustomer $orderCustomer): static
1520.     {
1521.         // set the owning side of the relation if necessary
1522.         if ($orderCustomer->getOrderId() !== $this) {
1523.             $orderCustomer->setOrderId($this);
1524.         }
1526.         $this->orderCustomer = $orderCustomer;
1528.         return $this;
1529.     }
1531.     public function getOrderCustomerAddress(): ?OrderCustomerAddress
1532.     {
1533.         return $this->orderCustomerAddress;
1534.     }
1536.     public function setOrderCustomerAddress(OrderCustomerAddress $orderCustomerAddress): static
1537.     {
1538.         // set the owning side of the relation if necessary
1539.         if ($orderCustomerAddress->getOrderId() !== $this) {
1540.             $orderCustomerAddress->setOrderId($this);
1541.         }
1543.         $this->orderCustomerAddress = $orderCustomerAddress;
1545.         return $this;
1546.     }
1548.     public function getContractSignedDate(): ?\DateTimeInterface
1549.     {
1550.         return $this->contractSignedDate;
1551.     }
1553.     public function setContractSignedDate(?\DateTimeInterface $contractSignedDate): static
1554.     {
1555.         $this->contractSignedDate = $contractSignedDate;
1557.         return $this;
1558.     }
1560.     /**
1562.      * @return Collection<int, OrderDivided>
1563.      */
1564.     public function getOrderDivideds(): Collection
1565.     {
1566.         return $this->orderDivideds;
1567.     }
1569.     public function addOrderDivided(OrderDivided $orderDivided): static
1570.     {
1571.         if (!$this->orderDivideds->contains($orderDivided)) {
1572.             $this->orderDivideds->add($orderDivided);
1573.             $orderDivided->setOrderId($this);
1574.         }
1576.         return $this;
1577.     }
1579.     /**
1580.      * @return Collection<int, MailHistory>
1581.      */
1582.     public function getMailHistories(): Collection
1583.     {
1584.         return $this->mailHistories;
1585.     }
1587.     public function addMailHistory(MailHistory $mailHistory): static
1588.     {
1589.         if (!$this->mailHistories->contains($mailHistory)) {
1590.             $this->mailHistories->add($mailHistory);
1591.             $mailHistory->setOrderInstance($this);
1592.         }
1594.         return $this;
1595.     }
1597.     public function removeOrderDivided(OrderDivided $orderDivided): static
1598.     {
1599.         if ($this->orderDivideds->removeElement($orderDivided)) {
1600.             // set the owning side to null (unless already changed)
1601.             if ($orderDivided->getOrderId() === $this) {
1602.                 $orderDivided->setOrderId(null);
1603.             }
1604.         }
1606.         return $this;
1607.     }
1609.     public function removeMailHistory(MailHistory $mailHistory): static
1610.     {
1611.         if ($this->mailHistories->removeElement($mailHistory)) {
1612.             // set the owning side to null (unless already changed)
1613.             if ($mailHistory->getOrderInstance() === $this) {
1614.                 $mailHistory->setOrderInstance(null);
1616.             }
1617.         }
1619.         return $this;
1620.     }
1622.     public function getOrderDividedSum(): float
1623.     {
1624.         $sum = 0;
1625.         foreach($this->getOrderDivideds() as $orderDivided){
1626.             $sum = $sum+$orderDivided->getValue();
1627.         }
1629.         return $sum;
1630.     }
1632.     public function isHaveInstalments(): ?bool
1633.     {
1634.         return $this->haveInstalments;
1635.     }
1637.     public function setHaveInstalments(bool $haveInstalments): static
1638.     {
1639.         $this->haveInstalments = $haveInstalments;
1641.         return $this;
1642.     }
1644.     public function getOrderNoteForExtension(): ?OrderNote
1645.     {
1646.         return $this->orderNoteForExtension;
1647.     }
1649.     public function setOrderNoteForExtension(?OrderNote $orderNoteForExtension): static
1650.     {
1651.         $this->orderNoteForExtension = $orderNoteForExtension;
1653.         return $this;
1654.     }
1656.     public function isImplementationCompletedWithoutAudit(): ?bool
1657.     {
1658.         return $this->implementationCompletedWithoutAudit;
1659.     }
1661.     public function setImplementationCompletedWithoutAudit(bool $implementationCompletedWithoutAudit): static
1662.     {
1663.         $this->implementationCompletedWithoutAudit = $implementationCompletedWithoutAudit;
1665.         return $this;
1666.     }
1668.     public function getDebtStatusChangeDate(): ?\DateTimeInterface
1669.     {
1670.         return $this->debtStatusChangeDate;
1671.     }
1673.     public function setDebtStatusChangeDate(?\DateTimeInterface $debtStatusChangeDate): static
1674.     {
1675.         $this->debtStatusChangeDate = $debtStatusChangeDate;
1677.         return $this;
1678.     }
1680.     /**
1681.      * @return Collection<int, Consultant>
1682.      */
1683.     public function getConsultantForNotes(): Collection
1684.     {
1685.         return $this->consultantForNotes;
1686.     }
1688.     /**
1689.      * @return Collection<int, Consultant>|Consultant|Admin
1690.      */
1691.     public function getCurrentConsultantsOrAdmin(): Collection|Consultant|Admin
1692.     {
1693.         $dateTimeNow = new DateTime();
1695.         $paymentDate = $this->getPaymentDate();
1696.         $dateOfPayment = $this->getDateOfPayment();
1698.         $consultant = $this->consultant;
1699.         $admin = $this->getAdmin();
1701.         $consultantsForNotes = $this->getConsultantForNotes();
1703.         if (empty($dateOfPayment) && $paymentDate !== null && $dateTimeNow > $paymentDate && !$consultantsForNotes->isEmpty()) {
1704.             return $consultantsForNotes;
1705.         } else {
1706.             return $consultant ?? $admin;
1707.         }
1708.     }
1710.     public function addConsultantForNote(Consultant $consultantForNote): static
1711.     {
1712.         if (!$this->consultantForNotes->contains($consultantForNote)) {
1713.             $this->consultantForNotes->add($consultantForNote);
1714.         }
1716.         return $this;
1717.     }
1719.     public function removeConsultantForNote(Consultant $consultantForNote): static
1720.     {
1721.         $this->consultantForNotes->removeElement($consultantForNote);
1723.         return $this;
1724.     }
1726.     /**
1727.      * @return Collection<int, Task>
1728.      */
1729.     public function getTasks(): Collection
1730.     {
1731.         return $this->tasks;
1732.     }
1734.     public function addTask(Task $task): static
1735.     {
1736.         if (!$this->tasks->contains($task)) {
1737.             $this->tasks->add($task);
1738.             $task->setOrderInstance($this);
1739.         }
1741.         return $this;
1742.     }
1744.     public function removeTask(Task $task): static
1745.     {
1746.         if ($this->tasks->removeElement($task)) {
1747.             // set the owning side to null (unless already changed)
1748.             if ($task->getOrderInstance() === $this) {
1749.                 $task->setOrderInstance(null);
1750.             }
1751.         }
1753.         return $this;
1754.     }
1756.     /**
1757.      * @return Collection<int, SmsHistory>
1758.      */
1759.     public function getSmsHistories(): Collection
1760.     {
1761.         return $this->smsHistories;
1762.     }
1764.     public function addSmsHistory(SmsHistory $smsHistory): static
1765.     {
1766.         if (!$this->smsHistories->contains($smsHistory)) {
1767.             $this->smsHistories->add($smsHistory);
1768.             $smsHistory->setOrderId($this);
1769.         }
1771.         return $this;
1772.     }
1774.     public function removeSmsHistory(SmsHistory $smsHistory): static
1775.     {
1776.         if ($this->smsHistories->removeElement($smsHistory)) {
1777.             // set the owning side to null (unless already changed)
1778.             if ($smsHistory->getOrderId() === $this) {
1779.                 $smsHistory->setOrderId(null);
1780.             }
1781.         }
1783.         return $this;
1784.     }
1786.     public function getNoticeDate(): ?\DateTimeInterface
1787.     {
1788.         return $this->noticeDate;
1789.     }
1791.     public function setNoticeDate(?\DateTimeInterface $noticeDate): static
1792.     {
1793.         $this->noticeDate = $noticeDate;
1795.         return $this;
1796.     }
1798.     /**
1799.      * @return Collection<int, SurveyResponse>
1800.      */
1801.     public function getSurveyResponses(): Collection
1802.     {
1803.         return $this->surveyResponses;
1804.     }
1806.     public function addSurveyResponse(SurveyResponse $surveyResponse): static
1807.     {
1808.         if (!$this->surveyResponses->contains($surveyResponse)) {
1809.             $this->surveyResponses->add($surveyResponse);
1810.             $surveyResponse->setOrderInstance($this);
1811.         }
1813.         return $this;
1814.     }
1816.     public function removeSurveyResponse(SurveyResponse $surveyResponse): static
1817.     {
1818.         if ($this->surveyResponses->removeElement($surveyResponse)) {
1819.             // set the owning side to null (unless already changed)
1820.             if ($surveyResponse->getOrderInstance() === $this) {
1821.                 $surveyResponse->setOrderInstance(null);
1822.             }
1823.         }
1825.         return $this;
1826.     }
1828.     /**
1829.      * @return Collection<int, ZoomList>
1830.      */
1831.     public function getZoomLists(): Collection
1832.     {
1833.         return $this->zoomLists;
1834.     }
1836.     public function addZoomList(ZoomList $zoomList): static
1837.     {
1838.         if (!$this->zoomLists->contains($zoomList)) {
1839.             $this->zoomLists->add($zoomList);
1840.             $zoomList->setOrderInstance($this);
1841.         }
1843.         return $this;
1844.     }
1846.     public function removeZoomList(ZoomList $zoomList): static
1847.     {
1848.         if ($this->zoomLists->removeElement($zoomList)) {
1849.             // set the owning side to null (unless already changed)
1850.             if ($zoomList->getOrderInstance() === $this) {
1851.                 $zoomList->setOrderInstance(null);
1852.             }
1853.         }
1855.         return $this;
1856.     }
1858.     public function getTokenLicencyjnaWebAml(): ?string
1859.     {
1860.         return $this->tokenLicencyjnaWebAml;
1861.     }
1863.     public function setTokenLicencyjnaWebAml(?string $tokenLicencyjnaWebAml): static
1864.     {
1865.         $this->tokenLicencyjnaWebAml = $tokenLicencyjnaWebAml;
1867.         return $this;
1868.     }
1870.     public function getTokenLicencyjnaWebAmlPartnerska(): ?string
1871.     {
1872.         return $this->tokenLicencyjnaWebAmlPartnerska;
1873.     }
1875.     public function setTokenLicencyjnaWebAmlPartnerska(?string $tokenLicencyjnaWebAmlPartnerska): static
1876.     {
1877.         $this->tokenLicencyjnaWebAmlPartnerska = $tokenLicencyjnaWebAmlPartnerska;
1879.         return $this;
1880.     }
1882.     public function getTokenLicencyjnaWebAmlNieruchomosci(): ?string
1883.     {
1884.         return $this->tokenLicencyjnaWebAmlNieruchomosci;
1885.     }
1887.     public function setTokenLicencyjnaWebAmlNieruchomosci(?string $tokenLicencyjnaWebAmlNieruchomosci): static
1888.     {
1889.         $this->tokenLicencyjnaWebAmlNieruchomosci = $tokenLicencyjnaWebAmlNieruchomosci;
1891.         return $this;
1892.     }
1894.     public function getDateForPoints(): ?\DateTimeInterface
1895.     {
1896.         return $this->dateForPoints;
1897.     }
1899.     public function setDateForPoints(?\DateTimeInterface $dateForPoints): static
1900.     {
1901.         $this->dateForPoints = $dateForPoints;
1903.         return $this;
1904.     }
1906.     public function isPointsAdded(): ?bool
1907.     {
1908.         return $this->pointsAdded;
1909.     }
1911.     public function setPointsAdded(bool $pointsAdded): static
1912.     {
1913.         $this->pointsAdded = $pointsAdded;
1915.         return $this;
1916.     }
1918.     public function isForCountingSprawozdaniaOther(): ?bool
1919.     {
1920.         return $this->forCountingSprawozdaniaOther;
1921.     }
1923.     public function setForCountingSprawozdaniaOther(bool $forCountingSprawozdaniaOther): static
1924.     {
1925.         $this->forCountingSprawozdaniaOther = $forCountingSprawozdaniaOther;
1927.         return $this;
1928.     }
1930.     public function getOrderProductAgreementToken(): string
1931.     {
1932.         $token = '';
1933.         foreach ($this->getOrderProduct() as $orderProduct) {
1934.             $token = match ($orderProduct->getProduct()->getAgreement()->getType()) {
1935.                 'rodo' => $orderProduct->getProduct()->getToken(),
1936.                 'aml' => $orderProduct->getProduct()->getTokenAml(),
1937.                 'amlrodo' => $orderProduct->getProduct()->getTokenAmlrodo(),
1938.                 'bdo' => $orderProduct->getProduct()->getTokenBdo(),
1939.                 'bhpstacjonarna' => $orderProduct->getProduct()->getTokenBhpStationary(),
1940.                 'biurarachunkowe' => $orderProduct->getProduct()->getTokenOffice(),
1941.                 'iod' => $orderProduct->getProduct()->getTokenIod(),
1942.                 'rodobhp' => $orderProduct->getProduct()->getTokenBhpRodo(),
1943.                 'licencyjnewebaml' => $orderProduct->getProduct()->getTokenLicencyjnaWebAml(),
1944.                 'licencyjnewebamlpartnerska' => $orderProduct->getProduct()->getTokenLicencyjnaWebAmlPartnerska(),
1945.                 'licencyjnewebamlnieruchomosci' => $orderProduct->getProduct()->getTokenLicencyjnaWebAmlNieruchomosci(),
1946.                 default => '',
1947.             };
1948.             if($token){
1949.                 return $token;
1950.             }else{
1951.                 return '';
1952.             }
1953.         }
1954.         return $token;
1955.     }
1957.     public function isAnnex(): ?bool
1958.     {
1959.         return $this->annex;
1960.     }
1962.     public function setAnnex(bool $annex): static
1963.     {
1964.         $this->annex = $annex;
1966.         return $this;
1967.     }
1969.     public function getTerminationDate(): ?\DateTimeInterface
1970.     {
1971.         return $this->terminationDate;
1972.     }
1974.     public function setTerminationDate(?\DateTimeInterface $terminationDate): static
1975.     {
1976.         $this->terminationDate = $terminationDate;
1978.         return $this;
1979.     }
1981.     public function isEffectivelyTerminated(): ?bool
1982.     {
1983.         return $this->effectivelyTerminated;
1984.     }
1986.     public function setEffectivelyTerminated(bool $effectivelyTerminated): static
1987.     {
1988.         $this->effectivelyTerminated = $effectivelyTerminated;
1990.         return $this;
1991.     }
1993.     public function getRootOrder(): ?self
1994.     {
1995.         $order = $this->getParentOrder();
1997.         if ($order === null) {
1998.             return null;
1999.         }
2001.         while ($order->getParentOrder() !== null) {
2002.             $order = $order->getParentOrder();
2003.         }
2005.         return $order;
2006.     }
2008.     public function getContractStartDate(): ?\DateTimeInterface
2009.     {
2010.         return $this->contractStartDate;
2011.     }
2013.     public function setContractStartDate(?\DateTimeInterface $contractStartDate): static
2014.     {
2015.         $this->contractStartDate = $contractStartDate;
2017.         return $this;
2018.     }
2019. }