1. <?php
3. namespace App\Entity\CRM;
5. use App\Entity\CRM\NominalWorkTime;
6. use App\Entity\CRM\Notification;
7. use App\Entity\CRM\Order;
8. use App\Entity\CRM\OrderDivided;
9. use App\Entity\CRM\OrderHistory;
10. use App\Entity\CRM\OrderNote;
11. use App\Entity\CRM\Position;
12. use App\Entity\CRM\Reservations;
13. use App\Entity\CRM\SmsHistory;
14. use App\Entity\CRM\SurveyResponse;
15. use App\Entity\CRM\WorkHistory;
16. use App\Entity\CRM\WorkTime;
17. use App\Entity\CRM\ZoomList;
18. use App\Repository\ConsultantRepository;
19. use Doctrine\Common\Collections\ArrayCollection;
20. use Doctrine\Common\Collections\Collection;
21. use Doctrine\DBAL\Types\Types;
22. use Doctrine\ORM\Mapping as ORM;
23. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
24. use Symfony\Component\Security\Core\User\UserInterface;
26. #[ORM\Entity(repositoryClass: ConsultantRepository::class)]
27. class Consultant implements UserInterface, PasswordAuthenticatedUserInterface
28. {
29.     #[ORM\Id]
30.     #[ORM\GeneratedValue]
31.     #[ORM\Column]
32.     private ?int $id = null;
34.     #[ORM\Column(length: 255)]
35.     private string $firstName;
37.     #[ORM\Column(length: 255)]
38.     private string $lastName;
40.     #[ORM\Column(length: 255)]
41.     private string $email;
43.     #[ORM\Column(length: 255, nullable: true)]
44.     private ?string $phone = null;
46.     #[ORM\Column(length: 64, nullable: true)]
47.     private ?string $lineNumber = null;
49.     #[ORM\Column(length: 255, nullable: true)]
50.     private ?string $photo = null;
52.     #[ORM\Column(length: 255, options: ['default' => 'sip.ipfon.pl'])]
53.     private string $sipServer = 'sip.ipfon.pl';
55.     #[ORM\Column(length: 255, nullable: true)]
56.     private ?string $sipLogin = null;
58.     #[ORM\Column(length: 255, nullable: true)]
59.     private ?string $sipPassword = null;
61.     #[ORM\Column]
62.     private ?bool $isActive = null;
64.     #[ORM\Column]
65.     private ?bool $featureTester = null;
67.     /**
68.      * @var string The hashed password
69.      */
70.     #[ORM\Column]
71.     private string $password;
73.     #[ORM\Column]
74.     private array $roles = [];
76.     #[ORM\ManyToOne(inversedBy: 'consultants')]
77.     #[ORM\JoinColumn(nullable: false)]
78.     private ?Department $department = null;
80.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: Order::class)]
81.     private Collection $orders;
83.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: Customer::class)]
84.     private Collection $customers;
86.     #[ORM\ManyToMany(targetEntity: Notification::class, mappedBy: 'consultant')]
87.     private Collection $notifications;
89.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: OrderNote::class)]
90.     private Collection $orderNotes;
92.     #[ORM\OneToMany(mappedBy: 'orderDividedConsultant', targetEntity: Order::class)]
93.     private Collection $dividedOrders;
95.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: OrderHistory::class)]
96.     private Collection $orderHistories;
98.     #[ORM\Column]
99.     private ?int $bonusPercentage = null;
101.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: ConsultantReward::class, orphanRemoval: true)]
102.     private Collection $consultantRewards;
104.     #[ORM\ManyToMany(targetEntity: CommercialOffer::class, mappedBy: 'AvailableForConsultants')]
105.     private Collection $commercialOffers;
107.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: WorkHistory::class)]
108.     private Collection $workHistories;
110.     #[ORM\OneToMany(mappedBy: 'createdByConsultant', targetEntity: CommercialOfferIndividual::class)]
111.     private Collection $commercialOfferIndividuals;
113.     #[ORM\OneToMany(mappedBy: 'addedByConsultant', targetEntity: CommercialOfferSendings::class)]
114.     private Collection $commercialOfferSendings;
116.     #[ORM\OneToMany(mappedBy: 'senderConsultant', targetEntity: DirectMessage::class)]
117.     private Collection $directMessagesSent;
119.     #[ORM\OneToMany(mappedBy: 'receiverConsultant', targetEntity: DirectMessage::class)]
120.     private Collection $directMessagesReceived;
122.     #[ORM\Column]
123.     private ?bool $remoteAccess = null;
125.     #[ORM\OneToMany(mappedBy: 'addedByConsultant', targetEntity: Reservations::class)]
126.     private Collection $reservations;
128.     #[ORM\Column(length: 255, nullable: true)]
129.     private ?string $color = null;
131.     #[ORM\OneToMany(mappedBy: 'Consultant', targetEntity: DebtNote::class)]
132.     private Collection $debtNotes;
134.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: OrderDivided::class, orphanRemoval: true)]
135.     private Collection $orderDivideds;
137.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: CustomerHistory::class)]
138.     private Collection $customerHistories;
140.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: Awards::class, orphanRemoval: true)]
141.     private Collection $awards;
143.     #[ORM\ManyToOne(inversedBy: 'consultants')]
144.     private ?AwardLeague $awardLeague = null;
146.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: AwardPtSum::class, orphanRemoval: true)]
147.     private Collection $awardPtSums;
149.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: AwardsDraw::class, orphanRemoval: true)]
150.     private Collection $awardsDraws;
152.     #[ORM\Column]
153.     private bool $inAwards = true;
155.     #[ORM\ManyToMany(targetEntity: Order::class, mappedBy: 'consultantForNotes')]
156.     private Collection $ordersToNotes;
158.     #[ORM\OneToMany(mappedBy: 'sendByConsultant', targetEntity: SmsHistory::class)]
159.     private Collection $smsHistories;
161.     #[ORM\OneToOne(mappedBy: 'Consultant', cascade: ['persist', 'remove'])]
162.     private ?NominalWorkTime $nominalWorkTime = null;
164.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: WorkTime::class)]
165.     private Collection $workTimes;
167.     #[ORM\Column]
168.     private ?bool $remoteWork = null;
170.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: LeaveRequest::class, orphanRemoval: true)]
171.     private Collection $leaveRequests;
173.     #[ORM\OneToMany(mappedBy: 'changedByConsultant', targetEntity: EntityChangeLog::class)]
174.     private Collection $entityChangeLogs;
176.     #[ORM\OneToMany(mappedBy: 'madeBy', targetEntity: SurveyResponse::class)]
177.     private Collection $surveyResponses;
179.     #[ORM\ManyToOne(inversedBy: 'consultants')]
180.     private ?Position $position = null;
182.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: ZoomList::class)]
183.     private Collection $zoomLists;
185.     #[ORM\ManyToOne(inversedBy: 'consultants')]
186.     private ?EmploymentContractType $consultantContractType = null;
188.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: AccountingOfficeSendingNote::class)]
189.     private Collection $accountingOfficeSendingNotes;
191.     #[ORM\Column]
192.     private ?bool $acceptedRegulations = null;
194.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
195.     private ?\DateTimeInterface $acceptedRegulationsDate = null;
197.     #[ORM\Column]
198.     private ?bool $acceptedZfss = null;
200.     #[ORM\Column(options: ['default' => false])]
201.     private bool $canViewBranchOrderLicences = false;
203.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
204.     private ?\DateTimeInterface $acceptedZfssDate = null;
206.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: LeaveRequestBalance::class)]
207.     private Collection $leaveRequestBalances;
209.     #[ORM\Column]
210.     private bool $disability = false;
212.     public function __construct()
213.     {
214.         $this->orders = new ArrayCollection();
215.         $this->customers = new ArrayCollection();
216.         $this->notifications = new ArrayCollection();
217.         $this->orderNotes = new ArrayCollection();
218.         $this->dividedOrders = new ArrayCollection();
219.         $this->orderHistories = new ArrayCollection();
220.         $this->consultantRewards = new ArrayCollection();
221.         $this->commercialOffers = new ArrayCollection();
222.         $this->workHistories = new ArrayCollection();
223.         $this->commercialOfferIndividuals = new ArrayCollection();
224.         $this->commercialOfferSendings = new ArrayCollection();
225.         $this->directMessagesSent = new ArrayCollection();
226.         $this->directMessagesReceived = new ArrayCollection();
227.         $this->reservations = new ArrayCollection();
228.         $this->debtNotes = new ArrayCollection();
229.         $this->customerHistories = new ArrayCollection();
230.         $this->awards = new ArrayCollection();
231.         $this->awardPtSums = new ArrayCollection();
232.         $this->awardsDraws = new ArrayCollection();
233.         $this->inAwards = true;
234.         $this->ordersToNotes = new ArrayCollection();
235.         $this->smsHistories = new ArrayCollection();
236.         $this->workTimes = new ArrayCollection();
237.         $this->leaveRequests = new ArrayCollection();
238.         $this->entityChangeLogs = new ArrayCollection();
239.         $this->surveyResponses = new ArrayCollection();
240.         $this->position = null;
241.         $this->zoomLists = new ArrayCollection();
242.         $this->accountingOfficeSendingNotes = new ArrayCollection();
243.         $this->acceptedZfss = false;
244.         $this->acceptedZfssDate = null;
245.         $this->leaveRequestBalances = new ArrayCollection();
246.     }
248.     public function __toString()
249.     {
250.         return $this->firstName . ' ' . $this->lastName;
251.     }
253.     public function getId(): ?int
254.     {
255.         return $this->id;
256.     }
258.     public function getFullName(): ?string
259.     {
260.         return $this->lastName . ' ' . $this->firstName;
261.     }
262.     public function getFirstName(): ?string
263.     {
264.         return $this->firstName;
265.     }
267.     public function setFirstName(string $firstName): self
268.     {
269.         $this->firstName = $firstName;
271.         return $this;
272.     }
274.     public function getLastName(): ?string
275.     {
276.         return $this->lastName;
277.     }
279.     public function setLastName(string $lastName): self
280.     {
281.         $this->lastName = $lastName;
283.         return $this;
284.     }
286.     public function getEmail(): ?string
287.     {
288.         return $this->email;
289.     }
291.     public function setEmail(?string $email): self
292.     {
293.         $this->email = $email;
295.         return $this;
296.     }
298.     public function getPhone(): ?string
299.     {
300.         return $this->phone;
301.     }
303.     public function setPhone(?string $phone): self
304.     {
305.         $this->phone = $phone;
307.         return $this;
308.     }
310.     public function getLineNumber(): ?string
311.     {
312.         return $this->lineNumber;
313.     }
315.     public function setLineNumber(?string $lineNumber): self
316.     {
317.         $this->lineNumber = $lineNumber;
319.         return $this;
320.     }
322.     public function getPhoto(): ?string
323.     {
324.         return $this->photo;
325.     }
327.     public function setPhoto(?string $photo): self
328.     {
329.         $this->photo = $photo;
331.         return $this;
332.     }
334.     public function getSipServer(): string
335.     {
336.         return $this->sipServer;
337.     }
339.     public function setSipServer(string $sipServer): self
340.     {
341.         $this->sipServer = $sipServer;
343.         return $this;
344.     }
346.     public function getSipLogin(): ?string
347.     {
348.         return $this->sipLogin;
349.     }
351.     public function setSipLogin(?string $sipLogin): self
352.     {
353.         $this->sipLogin = $sipLogin;
355.         return $this;
356.     }
358.     public function getSipPassword(): ?string
359.     {
360.         return $this->sipPassword;
361.     }
363.     public function setSipPassword(?string $sipPassword): self
364.     {
365.         $this->sipPassword = $sipPassword;
367.         return $this;
368.     }
370.     public function isActive(): ?bool
371.     {
372.         return $this->isActive;
373.     }
375.     public function setIsActive(bool $isActive): self
376.     {
377.         $this->isActive = $isActive;
379.         return $this;
380.     }
382.     /**
383.      * A visual identifier that represents this user.
384.      *
385.      * @see UserInterface
386.      */
387.     public function getUserIdentifier(): string
388.     {
389.         return (string) $this->email;
390.     }
392.     /**
393.      * @see UserInterface
394.      */
395.     public function getRoles(): array
396.     {
397.         $roles = $this->roles;
398.         // guarantee every user at least has ROLE_USER
399.         $roles[] = 'ROLE_CONSULTANT';
401.         return array_unique($roles);
402.     }
404.     /**
405.      * @see UserInterface
406.      */
407.     public function eraseCredentials()
408.     {
409.         // If you store any temporary, sensitive data on the user, clear it here
410.         // $this->plainPassword = null;
411.     }
413.     public function setRoles(array $roles): self
414.     {
415.         $this->roles = $roles;
417.         return $this;
418.     }
420.     public function getPassword(): ?string
421.     {
422.         return $this->password;
423.     }
425.     public function setPassword(string $password): self
426.     {
427.         $this->password = $password;
429.         return $this;
430.     }
432.     public function getDepartment(): ?department
433.     {
434.         return $this->department;
435.     }
437.     public function setDepartment(?department $department): self
438.     {
439.         $this->department = $department;
441.         return $this;
442.     }
444.     /**
445.      * @return Collection<int, Order>
446.      */
447.     public function getOrders(): Collection
448.     {
449.         return $this->orders;
450.     }
452.     public function addOrder(Order $order): self
453.     {
454.         if (!$this->orders->contains($order)) {
455.             $this->orders->add($order);
456.             $order->setConsultant($this);
457.         }
459.         return $this;
460.     }
462.     public function removeOrder(Order $order): self
463.     {
464.         if ($this->orders->removeElement($order)) {
465.             // set the owning side to null (unless already changed)
466.             if ($order->getConsultant() === $this) {
467.                 $order->setConsultant(null);
468.             }
469.         }
471.         return $this;
472.     }
474.     /**
475.      * @return Collection<int, Customer>
476.      */
477.     public function getCustomers(): Collection
478.     {
479.         return $this->customers;
480.     }
482.     public function addCustomer(Customer $customer): static
483.     {
484.         if (!$this->customers->contains($customer)) {
485.             $this->customers->add($customer);
486.             $customer->setConsultant($this);
487.         }
489.         return $this;
490.     }
492.     public function removeCustomer(Customer $customer): static
493.     {
494.         if ($this->customers->removeElement($customer)) {
495.             // set the owning side to null (unless already changed)
496.             if ($customer->getConsultant() === $this) {
497.                 $customer->setConsultant(null);
498.             }
499.         }
501.         return $this;
502.     }
504.     /**
505.      * @return Collection<int, Notification>
506.      */
507.     public function getNotifications(): Collection
508.     {
509.         return $this->notifications;
510.     }
512.     public function addNotification(Notification $notification): static
513.     {
514.         if (!$this->notifications->contains($notification)) {
515.             $this->notifications->add($notification);
516.             $notification->addConsultant($this);
517.         }
519.         return $this;
520.     }
522.     public function removeNotification(Notification $notification): static
523.     {
524.         if ($this->notifications->removeElement($notification)) {
525.             $notification->removeConsultant($this);
526.         }
528.         return $this;
529.     }
531.     /**
532.      * @return Collection<int, OrderNote>
533.      */
534.     public function getOrderNotes(): Collection
535.     {
536.         return $this->orderNotes;
537.     }
539.     public function addOrderNote(OrderNote $orderNote): static
540.     {
541.         if (!$this->orderNotes->contains($orderNote)) {
542.             $this->orderNotes->add($orderNote);
543.             $orderNote->setConsultant($this);
544.         }
546.         return $this;
547.     }
549.     public function removeOrderNote(OrderNote $orderNote): static
550.     {
551.         if ($this->orderNotes->removeElement($orderNote)) {
552.             // set the owning side to null (unless already changed)
553.             if ($orderNote->getConsultant() === $this) {
554.                 $orderNote->setConsultant(null);
555.             }
556.         }
558.         return $this;
559.     }
561.     /**
562.      * @return Collection<int, Order>
563.      */
564.     public function getDividedOrders(): Collection
565.     {
566.         return $this->dividedOrders;
567.     }
569.     public function addDividedOrder(Order $dividedOrder): static
570.     {
571.         if (!$this->dividedOrders->contains($dividedOrder)) {
572.             $this->dividedOrders->add($dividedOrder);
573.             $dividedOrder->setOrderDividedConsultant($this);
574.         }
576.         return $this;
577.     }
579.     public function removeDividedOrder(Order $dividedOrder): static
580.     {
581.         if ($this->dividedOrders->removeElement($dividedOrder)) {
582.             // set the owning side to null (unless already changed)
583.             if ($dividedOrder->getOrderDividedConsultant() === $this) {
584.                 $dividedOrder->setOrderDividedConsultant(null);
585.             }
586.         }
588.         return $this;
589.     }
591.     /**
592.      * @return Collection<int, OrderHistory>
593.      */
594.     public function getOrderHistories(): Collection
595.     {
596.         return $this->orderHistories;
597.     }
599.     public function addOrderHistory(OrderHistory $orderHistory): static
600.     {
601.         if (!$this->orderHistories->contains($orderHistory)) {
602.             $this->orderHistories->add($orderHistory);
603.             $orderHistory->setConsultant($this);
604.         }
606.         return $this;
607.     }
609.     public function removeOrderHistory(OrderHistory $orderHistory): static
610.     {
611.         if ($this->orderHistories->removeElement($orderHistory)) {
612.             // set the owning side to null (unless already changed)
613.             if ($orderHistory->getConsultant() === $this) {
614.                 $orderHistory->setConsultant(null);
615.             }
616.         }
618.         return $this;
619.     }
621.     public function getBonusPercentage(): ?int
622.     {
623.         return $this->bonusPercentage;
624.     }
626.     public function setBonusPercentage(int $bonusPercentage): static
627.     {
628.         $this->bonusPercentage = $bonusPercentage;
630.         return $this;
631.     }
633.     /**
634.      * @return Collection<int, ConsultantReward>
635.      */
636.     public function getConsultantRewards(): Collection
637.     {
638.         return $this->consultantRewards;
639.     }
641.     public function addConsultantReward(ConsultantReward $consultantReward): static
642.     {
643.         if (!$this->consultantRewards->contains($consultantReward)) {
644.             $this->consultantRewards->add($consultantReward);
645.             $consultantReward->setConsultant($this);
646.         }
648.         return $this;
649.     }
651.     public function removeConsultantReward(ConsultantReward $consultantReward): static
652.     {
653.         if ($this->consultantRewards->removeElement($consultantReward)) {
654.             // set the owning side to null (unless already changed)
655.             if ($consultantReward->getConsultant() === $this) {
656.                 $consultantReward->setConsultant(null);
657.             }
658.         }
660.         return $this;
661.     }
663.     /**
664.      * @return Collection<int, CommercialOffer>
665.      */
666.     public function getCommercialOffers(): Collection
667.     {
668.         return $this->commercialOffers;
669.     }
671.     public function addCommercialOffer(CommercialOffer $commercialOffer): static
672.     {
673.         if (!$this->commercialOffers->contains($commercialOffer)) {
674.             $this->commercialOffers->add($commercialOffer);
675.             $commercialOffer->addAvailableForConsultant($this);
676.         }
678.         return $this;
679.     }
681.     public function removeCommercialOffer(CommercialOffer $commercialOffer): static
682.     {
683.         if ($this->commercialOffers->removeElement($commercialOffer)) {
684.             $commercialOffer->removeAvailableForConsultant($this);
685.         }
687.         return $this;
688.     }
690.     /**
691.      * @return Collection<int, WorkHistory>
692.      */
693.     public function getWorkHistories(): Collection
694.     {
695.         return $this->workHistories;
696.     }
698.     public function addWorkHistory(WorkHistory $workHistory): static
699.     {
700.         if (!$this->workHistories->contains($workHistory)) {
701.             $this->workHistories->add($workHistory);
702.             $workHistory->setConsultant($this);
703.         }
705.         return $this;
706.     }
708.     public function removeWorkHistory(WorkHistory $workHistory): static
709.     {
710.         if ($this->workHistories->removeElement($workHistory)) {
711.             // set the owning side to null (unless already changed)
712.             if ($workHistory->getConsultant() === $this) {
713.                 $workHistory->setConsultant(null);
714.             }
715.         }
717.         return $this;
718.     }
720.     /**
721.      * @return Collection<int, CommercialOfferIndividual>
722.      */
723.     public function getIndividualCommercialOffers(): Collection
724.     {
725.         return $this->commercialOfferIndividuals;
726.     }
728.     public function addIndividualCommercialOffer(CommercialOfferIndividual $commercialOfferIndividual): static
729.     {
730.         if (!$this->commercialOfferIndividuals->contains($commercialOfferIndividual)) {
731.             $this->commercialOfferIndividuals->add($commercialOfferIndividual);
732.             $commercialOfferIndividual->setCreatedByConsultant($this);
733.         }
735.         return $this;
736.     }
738.     public function removeIndividualCommercialOffer(CommercialOfferIndividual $commercialOfferIndividual): static
739.     {
740.         if ($this->commercialOfferIndividuals->removeElement($commercialOfferIndividual)) {
741.             // set the owning side to null (unless already changed)
742.             if ($commercialOfferIndividual->getCreatedByConsultant() === $this) {
743.                 $commercialOfferIndividual->setCreatedByConsultant(null);
744.             }
745.         }
747.         return $this;
748.     }
750.     /**
751.      * @return Collection<int, CommercialOfferSendings>
752.      */
753.     public function getCommercialOfferSendings(): Collection
754.     {
755.         return $this->commercialOfferSendings;
756.     }
758.     public function addCommercialOfferSending(CommercialOfferSendings $commercialOfferSending): static
759.     {
760.         if (!$this->commercialOfferSendings->contains($commercialOfferSending)) {
761.             $this->commercialOfferSendings->add($commercialOfferSending);
762.             $commercialOfferSending->setAddedByConsultant($this);
763.         }
765.         return $this;
766.     }
768.     public function removeCommercialOfferSending(CommercialOfferSendings $commercialOfferSending): static
769.     {
770.         if ($this->commercialOfferSendings->removeElement($commercialOfferSending)) {
771.             // set the owning side to null (unless already changed)
772.             if ($commercialOfferSending->getAddedByConsultant() === $this) {
773.                 $commercialOfferSending->setAddedByConsultant(null);
774.             }
775.         }
777.         return $this;
778.     }
780.     /**
781.      * @return Collection<int, DirectMessage>
782.      */
783.     public function getDirectMessagesSent(): Collection
784.     {
785.         return $this->directMessagesSent;
786.     }
788.     public function addDirectMessagesSent(DirectMessage $directMessagesSent): static
789.     {
790.         if (!$this->directMessagesSent->contains($directMessagesSent)) {
791.             $this->directMessagesSent->add($directMessagesSent);
792.             $directMessagesSent->setSenderConsultant($this);
793.         }
795.         return $this;
796.     }
798.     public function removeDirectMessagesSent(DirectMessage $directMessagesSent): static
799.     {
800.         if ($this->directMessagesSent->removeElement($directMessagesSent)) {
801.             // set the owning side to null (unless already changed)
802.             if ($directMessagesSent->getSenderConsultant() === $this) {
803.                 $directMessagesSent->setSenderConsultant(null);
804.             }
805.         }
807.         return $this;
808.     }
810.     /**
811.      * @return Collection<int, DirectMessage>
812.      */
813.     public function getDirectMessagesReceived(): Collection
814.     {
815.         return $this->directMessagesReceived;
816.     }
818.     public function addDirectMessagesReceived(DirectMessage $directMessagesReceived): static
819.     {
820.         if (!$this->directMessagesReceived->contains($directMessagesReceived)) {
821.             $this->directMessagesReceived->add($directMessagesReceived);
822.             $directMessagesReceived->setReceiverConsultant($this);
823.         }
825.         return $this;
826.     }
828.     public function removeDirectMessagesReceived(DirectMessage $directMessagesReceived): static
829.     {
830.         if ($this->directMessagesReceived->removeElement($directMessagesReceived)) {
831.             // set the owning side to null (unless already changed)
832.             if ($directMessagesReceived->getReceiverConsultant() === $this) {
833.                 $directMessagesReceived->setReceiverConsultant(null);
834.             }
835.         }
837.         return $this;
838.     }
840.     public function isRemoteAccess(): ?bool
841.     {
842.         return $this->remoteAccess;
843.     }
845.     public function setRemoteAccess(bool $remoteAccess): static
846.     {
847.         $this->remoteAccess = $remoteAccess;
849.         return $this;
850.     }
852.     /**
853.      * @return Collection<int, Reservations>
854.      */
855.     public function getReservations(): Collection
856.     {
857.         return $this->reservations;
858.     }
860.     public function addReservation(Reservations $reservation): static
861.     {
862.         if (!$this->reservations->contains($reservation)) {
863.             $this->reservations->add($reservation);
864.             $reservation->setAddedByConsultant($this);
865.         }
867.         return $this;
868.     }
870.     public function removeReservation(Reservations $reservation): static
871.     {
872.         if ($this->reservations->removeElement($reservation)) {
873.             // set the owning side to null (unless already changed)
874.             if ($reservation->getAddedByConsultant() === $this) {
875.                 $reservation->setAddedByConsultant(null);
876.             }
877.         }
879.         return $this;
880.     }
882.     public function getColor(): ?string
883.     {
884.         return $this->color;
885.     }
887.     public function setColor(?string $color): static
888.     {
889.         $this->color = $color;
891.         return $this;
892.     }
894.     /**
895.      * @return Collection<int, DebtNote>
896.      */
897.     public function getDebtNotes(): Collection
898.     {
899.         return $this->debtNotes;
900.     }
902.     public function addDebtNote(DebtNote $debtNote): static
903.     {
904.         if (!$this->debtNotes->contains($debtNote)) {
905.             $this->debtNotes->add($debtNote);
906.             $debtNote->setConsultant($this);
907.         }
909.         return $this;
910.     }
912.     public function removeDebtNote(DebtNote $debtNote): static
913.     {
914.         if ($this->debtNotes->removeElement($debtNote)) {
915.             // set the owning side to null (unless already changed)
916.             if ($debtNote->getConsultant() === $this) {
917.                 $debtNote->setConsultant(null);
918.             }
919.         }
921.         return $this;
922.     }
924.     public function getOrderDivideds(): Collection
925.     {
926.         return $this->orderDivideds;
927.     }
929.     public function setOrderDivideds(Collection $orderDivideds): void
930.     {
931.         $this->orderDivideds = $orderDivideds;
932.     }
933.     public function removeOrderDivided(OrderDivided $orderDivided): static
934.     {
935.         if ($this->orderDivideds->removeElement($orderDivided)) {
936.             // set the owning side to null (unless already changed)
937.             if ($orderDivided->getConsultant() === $this) {
938.                 $orderDivided->setConsultant(null);
939.             }
940.         }
942.         return $this;
943.     }
945.     /**
946.      * @return Collection<int, CustomerHistory>
947.      */
948.     public function getCustomerHistories(): Collection
949.     {
950.         return $this->customerHistories;
951.     }
953.     public function addCustomerHistory(CustomerHistory $customerHistory): static
954.     {
955.         if (!$this->customerHistories->contains($customerHistory)) {
956.             $this->customerHistories->add($customerHistory);
957.             $customerHistory->setConsultant($this);
958.         }
960.         return $this;
961.     }
963.     public function removeCustomerHistory(CustomerHistory $customerHistory): static
964.     {
965.         if ($this->customerHistories->removeElement($customerHistory)) {
966.             // set the owning side to null (unless already changed)
967.             if ($customerHistory->getConsultant() === $this) {
968.                 $customerHistory->setConsultant(null);
969.             }
970.         }
972.         return $this;
973.     }
975.     /**
976.      * @return Collection<int, Awards>
977.      */
978.     public function getAwards(): Collection
979.     {
980.         return $this->awards;
981.     }
983.     public function addAward(Awards $award): static
984.     {
985.         if (!$this->awards->contains($award)) {
986.             $this->awards->add($award);
987.             $award->setConsultant($this);
988.         }
990.         return $this;
991.     }
993.     public function removeAward(Awards $award): static
994.     {
995.         if ($this->awards->removeElement($award)) {
996.             // set the owning side to null (unless already changed)
997.             if ($award->getConsultant() === $this) {
998.                 $award->setConsultant(null);
999.             }
1000.         }
1002.         return $this;
1003.     }
1005.     public function getAwardLeague(): ?AwardLeague
1006.     {
1007.         return $this->awardLeague;
1008.     }
1010.     public function setAwardLeague(?AwardLeague $awardLeague): static
1011.     {
1012.         $this->awardLeague = $awardLeague;
1014.         return $this;
1015.     }
1017.     /**
1018.      * @return Collection<int, AwardPtSum>
1019.      */
1020.     public function getAwardPtSums(): Collection
1021.     {
1022.         return $this->awardPtSums;
1023.     }
1025.     public function addAwardPtSum(AwardPtSum $awardPtSum): static
1026.     {
1027.         if (!$this->awardPtSums->contains($awardPtSum)) {
1028.             $this->awardPtSums->add($awardPtSum);
1029.             $awardPtSum->setConsultant($this);
1030.         }
1032.         return $this;
1033.     }
1035.     public function removeAwardPtSum(AwardPtSum $awardPtSum): static
1036.     {
1037.         if ($this->awardPtSums->removeElement($awardPtSum)) {
1038.             // set the owning side to null (unless already changed)
1039.             if ($awardPtSum->getConsultant() === $this) {
1040.                 $awardPtSum->setConsultant(null);
1041.             }
1042.         }
1044.         return $this;
1045.     }
1047.     /**
1048.      * @return Collection<int, AwardsDraw>
1049.      */
1050.     public function getAwardsDraws(): Collection
1051.     {
1052.         return $this->awardsDraws;
1053.     }
1055.     public function addAwardsDraw(AwardsDraw $awardsDraw): static
1056.     {
1057.         if (!$this->awardsDraws->contains($awardsDraw)) {
1058.             $this->awardsDraws->add($awardsDraw);
1059.             $awardsDraw->setConsultant($this);
1060.         }
1062.         return $this;
1063.     }
1065.     public function removeAwardsDraw(AwardsDraw $awardsDraw): static
1066.     {
1067.         if ($this->awardsDraws->removeElement($awardsDraw)) {
1068.             // set the owning side to null (unless already changed)
1069.             if ($awardsDraw->getConsultant() === $this) {
1070.                 $awardsDraw->setConsultant(null);
1071.             }
1072.         }
1074.         return $this;
1075.     }
1077.     public function isInAwards(): bool
1078.     {
1079.         return $this->inAwards;
1080.     }
1082.     public function setInAwards(bool $inAwards): static
1083.     {
1084.         $this->inAwards = $inAwards;
1086.         return $this;
1087.     }
1089.     /**
1090.      * @return Collection<int, Order>
1091.      */
1092.     public function getOrdersToNotes(): Collection
1093.     {
1094.         return $this->ordersToNotes;
1095.     }
1097.     public function addOrdersToNote(Order $ordersToNote): static
1098.     {
1099.         if (!$this->ordersToNotes->contains($ordersToNote)) {
1100.             $this->ordersToNotes->add($ordersToNote);
1101.             $ordersToNote->addConsultantForNote($this);
1102.         }
1104.         return $this;
1105.     }
1107.     public function removeOrdersToNote(Order $ordersToNote): static
1108.     {
1109.         if ($this->ordersToNotes->removeElement($ordersToNote)) {
1110.             $ordersToNote->removeConsultantForNote($this);
1111.         }
1113.         return $this;
1114.     }
1116.     /**
1117.      * @return Collection<int, SmsHistory>
1118.      */
1119.     public function getSmsHistories(): Collection
1120.     {
1121.         return $this->smsHistories;
1122.     }
1124.     public function addSmsHistory(SmsHistory $smsHistory): static
1125.     {
1126.         if (!$this->smsHistories->contains($smsHistory)) {
1127.             $this->smsHistories->add($smsHistory);
1128.             $smsHistory->setSendByConsultant($this);
1129.         }
1131.         return $this;
1132.     }
1134.     public function removeSmsHistory(SmsHistory $smsHistory): static
1135.     {
1136.         if ($this->smsHistories->removeElement($smsHistory)) {
1137.             // set the owning side to null (unless already changed)
1138.             if ($smsHistory->getSendByConsultant() === $this) {
1139.                 $smsHistory->setSendByConsultant(null);
1140.             }
1141.         }
1143.         return $this;
1144.     }
1146.     public function getNominalWorkTime(): ?NominalWorkTime
1147.     {
1148.         return $this->nominalWorkTime;
1149.     }
1151.     public function setNominalWorkTime(?NominalWorkTime $nominalWorkTime): static
1152.     {
1153.         // unset the owning side of the relation if necessary
1154.         if ($nominalWorkTime === null && $this->nominalWorkTime !== null) {
1155.             $this->nominalWorkTime->setConsultant(null);
1156.         }
1158.         // set the owning side of the relation if necessary
1159.         if ($nominalWorkTime !== null && $nominalWorkTime->getConsultant() !== $this) {
1160.             $nominalWorkTime->setConsultant($this);
1161.         }
1163.         $this->nominalWorkTime = $nominalWorkTime;
1165.         return $this;
1166.     }
1168.     /**
1169.      * @return Collection<int, WorkTime>
1170.      */
1171.     public function getWorkTimes(): Collection
1172.     {
1173.         return $this->workTimes;
1174.     }
1176.     public function addWorkTime(WorkTime $workTime): static
1177.     {
1178.         if (!$this->workTimes->contains($workTime)) {
1179.             $this->workTimes->add($workTime);
1180.             $workTime->setConsultant($this);
1181.         }
1183.         return $this;
1184.     }
1186.     public function removeWorkTime(WorkTime $workTime): static
1187.     {
1188.         if ($this->workTimes->removeElement($workTime)) {
1189.             // set the owning side to null (unless already changed)
1190.             if ($workTime->getConsultant() === $this) {
1191.                 $workTime->setConsultant(null);
1192.             }
1193.         }
1195.         return $this;
1196.     }
1198.     public function isRemoteWork(): ?bool
1199.     {
1200.         return $this->remoteWork;
1201.     }
1203.     public function setRemoteWork(bool $remoteWork): static
1204.     {
1205.         $this->remoteWork = $remoteWork;
1207.         return $this;
1208.     }
1210.     /**
1211.      * @return Collection<int, LeaveRequest>
1212.      */
1213.     public function getLeaveRequests(): Collection
1214.     {
1215.         return $this->leaveRequests;
1216.     }
1218.     public function getLeaveRequestsFrom2026(): Collection
1219.     {
1220.         return $this->leaveRequests->filter(function (LeaveRequest $lr) {
1221.             return $lr->getStartTime() >= new \DateTimeImmutable('2026-01-01 00:00:00');
1222.         });
1223.     }
1225.     public function addLeaveRequest(LeaveRequest $leaveRequest): static
1226.     {
1227.         if (!$this->leaveRequests->contains($leaveRequest)) {
1228.             $this->leaveRequests->add($leaveRequest);
1229.             $leaveRequest->setConsultant($this);
1230.         }
1232.         return $this;
1233.     }
1235.     public function removeLeaveRequest(LeaveRequest $leaveRequest): static
1236.     {
1237.         if ($this->leaveRequests->removeElement($leaveRequest)) {
1238.             // set the owning side to null (unless already changed)
1239.             if ($leaveRequest->getConsultant() === $this) {
1240.                 $leaveRequest->setConsultant(null);
1241.             }
1242.         }
1244.         return $this;
1245.     }
1247.     /**
1248.      * @return Collection<int, EntityChangeLog>
1249.      */
1250.     public function getEntityChangeLogs(): Collection
1251.     {
1252.         return $this->entityChangeLogs;
1253.     }
1255.     public function addEntityChangeLog(EntityChangeLog $entityChangeLog): static
1256.     {
1257.         if (!$this->entityChangeLogs->contains($entityChangeLog)) {
1258.             $this->entityChangeLogs->add($entityChangeLog);
1259.             $entityChangeLog->setChangedByConsultant($this);
1260.         }
1262.         return $this;
1263.     }
1265.     public function removeEntityChangeLog(EntityChangeLog $entityChangeLog): static
1266.     {
1267.         if ($this->entityChangeLogs->removeElement($entityChangeLog)) {
1268.             // set the owning side to null (unless already changed)
1269.             if ($entityChangeLog->getChangedByConsultant() === $this) {
1270.                 $entityChangeLog->setChangedByConsultant(null);
1271.             }
1272.         }
1274.         return $this;
1275.     }
1277.     /**
1278.      * @return Collection<int, SurveyResponse>
1279.      */
1280.     public function getSurveyResponses(): Collection
1281.     {
1282.         return $this->surveyResponses;
1283.     }
1285.     public function addSurveyResponse(SurveyResponse $surveyResponse): static
1286.     {
1287.         if (!$this->surveyResponses->contains($surveyResponse)) {
1288.             $this->surveyResponses->add($surveyResponse);
1289.             $surveyResponse->setMadeBy($this);
1290.         }
1292.         return $this;
1293.     }
1295.     public function removeSurveyResponse(SurveyResponse $surveyResponse): static
1296.     {
1297.         if ($this->surveyResponses->removeElement($surveyResponse)) {
1298.             // set the owning side to null (unless already changed)
1299.             if ($surveyResponse->getMadeBy() === $this) {
1300.                 $surveyResponse->setMadeBy(null);
1301.             }
1302.         }
1303.         return $this;
1304.     }
1305.     public function getPosition(): ?Position
1306.     {
1307.         return $this->position;
1308.     }
1310.     public function setPosition(?Position $position): static
1311.     {
1312.         $this->position = $position;
1314.         return $this;
1315.     }
1317.     /**
1318.      * @return Collection<int, ZoomList>
1319.      */
1320.     public function getZoomLists(): Collection
1321.     {
1322.         return $this->zoomLists;
1323.     }
1325.     public function addZoomList(ZoomList $zoomList): static
1326.     {
1327.         if (!$this->zoomLists->contains($zoomList)) {
1328.             $this->zoomLists->add($zoomList);
1329.             $zoomList->setConsultant($this);
1330.         }
1332.         return $this;
1333.     }
1335.     public function removeZoomList(ZoomList $zoomList): static
1336.     {
1337.         if ($this->zoomLists->removeElement($zoomList)) {
1338.             // set the owning side to null (unless already changed)
1339.             if ($zoomList->getConsultant() === $this) {
1340.                 $zoomList->setConsultant(null);
1341.             }
1342.         }
1344.         return $this;
1345.     }
1347.     public function getConsultantContractType(): ?EmploymentContractType
1348.     {
1349.         return $this->consultantContractType;
1350.     }
1352.     public function setConsultantContractType(?EmploymentContractType $consultantContractType): static
1353.     {
1354.         $this->consultantContractType = $consultantContractType;
1356.         return $this;
1357.     }
1359.     /**
1360.      * @return Collection<int, AccountingOfficeSendingNote>
1361.      */
1362.     public function getAccountingOfficeSendingNotes(): Collection
1363.     {
1364.         return $this->accountingOfficeSendingNotes;
1365.     }
1367.     public function addAccountingOfficeSendingNote(AccountingOfficeSendingNote $accountingOfficeSendingNote): static
1368.     {
1369.         if (!$this->accountingOfficeSendingNotes->contains($accountingOfficeSendingNote)) {
1370.             $this->accountingOfficeSendingNotes->add($accountingOfficeSendingNote);
1371.             $accountingOfficeSendingNote->setConsultant($this);
1372.         }
1374.         return $this;
1375.     }
1377.     public function removeAccountingOfficeSendingNote(AccountingOfficeSendingNote $accountingOfficeSendingNote): static
1378.     {
1379.         if ($this->accountingOfficeSendingNotes->removeElement($accountingOfficeSendingNote)) {
1380.             // set the owning side to null (unless already changed)
1381.             if ($accountingOfficeSendingNote->getConsultant() === $this) {
1382.                 $accountingOfficeSendingNote->setConsultant(null);
1383.             }
1384.         }
1386.         return $this;
1387.     }
1389.     public function isAcceptedRegulations(): ?bool
1390.     {
1391.         return $this->acceptedRegulations;
1392.     }
1394.     public function setAcceptedRegulations(bool $acceptedRegulations): static
1395.     {
1396.         $this->acceptedRegulations = $acceptedRegulations;
1398.         return $this;
1399.     }
1401.     public function getAcceptedRegulationsDate(): ?\DateTimeInterface
1402.     {
1403.         return $this->acceptedRegulationsDate;
1404.     }
1406.     public function setAcceptedRegulationsDate(?\DateTimeInterface $acceptedRegulationsDate): static
1407.     {
1408.         $this->acceptedRegulationsDate = $acceptedRegulationsDate;
1410.         return $this;
1411.     }
1413.     public function isAcceptedZfss(): ?bool
1414.     {
1415.         return $this->acceptedZfss;
1416.     }
1418.     public function setAcceptedZfss(bool $acceptedZfss): static
1419.     {
1420.         $this->acceptedZfss = $acceptedZfss;
1422.         return $this;
1423.     }
1425.     public function isCanViewBranchOrderLicences(): bool
1426.     {
1427.         return $this->canViewBranchOrderLicences;
1428.     }
1430.     public function setCanViewBranchOrderLicences(bool $canViewBranchOrderLicences): static
1431.     {
1432.         $this->canViewBranchOrderLicences = $canViewBranchOrderLicences;
1434.         return $this;
1435.     }
1437.     public function getAcceptedZfssDate(): ?\DateTimeInterface
1438.     {
1439.         return $this->acceptedZfssDate;
1440.     }
1442.     public function setAcceptedZfssDate(?\DateTimeInterface $acceptedZfssDate): static
1443.     {
1444.         $this->acceptedZfssDate = $acceptedZfssDate;
1446.         return $this;
1447.     }
1449.     /**
1450.      * @return Collection<int, LeaveRequestBalance>
1451.      */
1452.     public function getLeaveRequestBalances(): Collection
1453.     {
1454.         return $this->leaveRequestBalances;
1455.     }
1457.     public function addLeaveRequestBalance(LeaveRequestBalance $leaveRequestBalance): static
1458.     {
1459.         if (!$this->leaveRequestBalances->contains($leaveRequestBalance)) {
1460.             $this->leaveRequestBalances->add($leaveRequestBalance);
1461.             $leaveRequestBalance->setConsultant($this);
1462.         }
1464.         return $this;
1465.     }
1467.     public function removeLeaveRequestBalance(LeaveRequestBalance $leaveRequestBalance): static
1468.     {
1469.         if ($this->leaveRequestBalances->removeElement($leaveRequestBalance)) {
1470.             // set the owning side to null (unless already changed)
1471.             if ($leaveRequestBalance->getConsultant() === $this) {
1472.                 $leaveRequestBalance->setConsultant(null);
1473.             }
1474.         }
1476.         return $this;
1477.     }
1479.     public function getTodayWorkTimeFromLoadedCollection(): ?WorkTime
1480.     {
1481.         $today = (new \DateTimeImmutable('today'))->format('Y-m-d');
1483.         foreach ($this->getWorkTimes() as $workTime) {
1484.             if ($workTime->getWorkDate()?->format('Y-m-d') === $today) {
1485.                 return $workTime;
1486.             }
1487.         }
1489.         return null;
1490.     }
1492.     public function getFeatureTester(): ?bool
1493.     {
1494.         return $this->featureTester;
1495.     }
1497.     public function setFeatureTester(?bool $featureTester): void
1498.     {
1499.         $this->featureTester = $featureTester;
1500.     }
1502.     public function isDisability(): bool
1503.     {
1504.         return $this->disability;
1505.     }
1507.     public function setDisability(bool $disability): void
1508.     {
1509.         $this->disability = $disability;
1510.     }
1511. }