src/Entity/CRM/Consultant.php line 27

  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: 255, nullable: true)]
  47.     private ?string $photo = null;
  49.     #[ORM\Column]
  50.     private ?bool $isActive = null;
  52.     /**
  53.      * @var string The hashed password
  54.      */
  55.     #[ORM\Column]
  56.     private string $password;
  58.     #[ORM\Column]
  59.     private array $roles = [];
  61.     #[ORM\ManyToOne(inversedBy: 'consultants')]
  62.     #[ORM\JoinColumn(nullable: false)]
  63.     private ?Department $department = null;
  65.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: Order::class)]
  66.     private Collection $orders;
  68.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: Customer::class)]
  69.     private Collection $customers;
  71.     #[ORM\ManyToMany(targetEntity: Notification::class, mappedBy: 'consultant')]
  72.     private Collection $notifications;
  74.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: OrderNote::class)]
  75.     private Collection $orderNotes;
  77.     #[ORM\OneToMany(mappedBy: 'orderDividedConsultant', targetEntity: Order::class)]
  78.     private Collection $dividedOrders;
  80.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: OrderHistory::class)]
  81.     private Collection $orderHistories;
  83.     #[ORM\Column]
  84.     private ?int $bonusPercentage = null;
  86.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: ConsultantReward::class, orphanRemoval: true)]
  87.     private Collection $consultantRewards;
  89.     #[ORM\ManyToMany(targetEntity: CommercialOffer::class, mappedBy: 'AvailableForConsultants')]
  90.     private Collection $commercialOffers;
  92.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: WorkHistory::class)]
  93.     private Collection $workHistories;
  95.     #[ORM\OneToMany(mappedBy: 'createdByConsultant', targetEntity: CommercialOfferIndividual::class)]
  96.     private Collection $commercialOfferIndividuals;
  98.     #[ORM\OneToMany(mappedBy: 'addedByConsultant', targetEntity: CommercialOfferSendings::class)]
  99.     private Collection $commercialOfferSendings;
  101.     #[ORM\OneToMany(mappedBy: 'senderConsultant', targetEntity: DirectMessage::class)]
  102.     private Collection $directMessagesSent;
  104.     #[ORM\OneToMany(mappedBy: 'receiverConsultant', targetEntity: DirectMessage::class)]
  105.     private Collection $directMessagesReceived;
  107.     #[ORM\Column]
  108.     private ?bool $remoteAccess = null;
  110.     #[ORM\OneToMany(mappedBy: 'addedByConsultant', targetEntity: Reservations::class)]
  111.     private Collection $reservations;
  113.     #[ORM\Column(length: 255, nullable: true)]
  114.     private ?string $color = null;
  116.     #[ORM\OneToMany(mappedBy: 'Consultant', targetEntity: DebtNote::class)]
  117.     private Collection $debtNotes;
  119.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: OrderDivided::class, orphanRemoval: true)]
  120.     private Collection $orderDivideds;
  122.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: CustomerHistory::class)]
  123.     private Collection $customerHistories;
  125.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: Awards::class, orphanRemoval: true)]
  126.     private Collection $awards;
  128.     #[ORM\ManyToOne(inversedBy: 'consultants')]
  129.     private ?AwardLeague $awardLeague = null;
  131.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: AwardPtSum::class, orphanRemoval: true)]
  132.     private Collection $awardPtSums;
  134.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: AwardsDraw::class, orphanRemoval: true)]
  135.     private Collection $awardsDraws;
  137.     #[ORM\Column]
  138.     private bool $inAwards = true;
  140.     #[ORM\ManyToMany(targetEntity: Order::class, mappedBy: 'consultantForNotes')]
  141.     private Collection $ordersToNotes;
  143.     #[ORM\OneToMany(mappedBy: 'sendByConsultant', targetEntity: SmsHistory::class)]
  144.     private Collection $smsHistories;
  146.     #[ORM\OneToOne(mappedBy: 'Consultant', cascade: ['persist', 'remove'])]
  147.     private ?NominalWorkTime $nominalWorkTime = null;
  149.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: WorkTime::class)]
  150.     private Collection $workTimes;
  152.     #[ORM\Column]
  153.     private ?bool $remoteWork = null;
  155.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: LeaveRequest::class, orphanRemoval: true)]
  156.     private Collection $leaveRequests;
  158.     #[ORM\OneToMany(mappedBy: 'changedByConsultant', targetEntity: EntityChangeLog::class)]
  159.     private Collection $entityChangeLogs;
  161.     #[ORM\OneToMany(mappedBy: 'madeBy', targetEntity: SurveyResponse::class)]
  162.     private Collection $surveyResponses;
  164.     #[ORM\ManyToOne(inversedBy: 'consultants')]
  165.     private ?Position $position = null;
  167.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: ZoomList::class)]
  168.     private Collection $zoomLists;
  170.     #[ORM\ManyToOne(inversedBy: 'consultants')]
  171.     private ?EmploymentContractType $consultantContractType = null;
  173.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: AccountingOfficeSendingNote::class)]
  174.     private Collection $accountingOfficeSendingNotes;
  176.     #[ORM\Column]
  177.     private ?bool $acceptedRegulations = null;
  179.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  180.     private ?\DateTimeInterface $acceptedRegulationsDate = null;
  182.     #[ORM\Column]
  183.     private ?bool $acceptedZfss = null;
  185.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  186.     private ?\DateTimeInterface $acceptedZfssDate = null;
  188.     #[ORM\OneToMany(mappedBy: 'consultant', targetEntity: LeaveRequestBalance::class)]
  189.     private Collection $leaveRequestBalances;
  192.     public function __construct()
  193.     {
  194.         $this->orders = new ArrayCollection();
  195.         $this->customers = new ArrayCollection();
  196.         $this->notifications = new ArrayCollection();
  197.         $this->orderNotes = new ArrayCollection();
  198.         $this->dividedOrders = new ArrayCollection();
  199.         $this->orderHistories = new ArrayCollection();
  200.         $this->consultantRewards = new ArrayCollection();
  201.         $this->commercialOffers = new ArrayCollection();
  202.         $this->workHistories = new ArrayCollection();
  203.         $this->commercialOfferIndividuals = new ArrayCollection();
  204.         $this->commercialOfferSendings = new ArrayCollection();
  205.         $this->directMessagesSent = new ArrayCollection();
  206.         $this->directMessagesReceived = new ArrayCollection();
  207.         $this->reservations = new ArrayCollection();
  208.         $this->debtNotes = new ArrayCollection();
  209.         $this->customerHistories = new ArrayCollection();
  210.         $this->awards = new ArrayCollection();
  211.         $this->awardPtSums = new ArrayCollection();
  212.         $this->awardsDraws = new ArrayCollection();
  213.         $this->inAwards = true;
  214.         $this->ordersToNotes = new ArrayCollection();
  215.         $this->smsHistories = new ArrayCollection();
  216.         $this->workTimes = new ArrayCollection();
  217.         $this->leaveRequests = new ArrayCollection();
  218.         $this->entityChangeLogs = new ArrayCollection();
  219.         $this->surveyResponses = new ArrayCollection();
  220.         $this->position = null;
  221.         $this->zoomLists = new ArrayCollection();
  222.         $this->accountingOfficeSendingNotes = new ArrayCollection();
  223.         $this->acceptedZfss = false;
  224.         $this->acceptedZfssDate = null;
  225.         $this->leaveRequestBalances = new ArrayCollection();
  226.     }
  228.     public function __toString()
  229.     {
  230.         return $this->firstName.' '.$this->lastName;
  231.     }
  233.     public function getId(): ?int
  234.     {
  235.         return $this->id;
  236.     }
  238.     public function getFullName(): ?string
  239.     {
  240.         return $this->lastName.' '.$this->firstName;
  241.     }
  242.     public function getFirstName(): ?string
  243.     {
  244.         return $this->firstName;
  245.     }
  247.     public function setFirstName(string $firstName): self
  248.     {
  249.         $this->firstName = $firstName;
  251.         return $this;
  252.     }
  254.     public function getLastName(): ?string
  255.     {
  256.         return $this->lastName;
  257.     }
  259.     public function setLastName(string $lastName): self
  260.     {
  261.         $this->lastName = $lastName;
  263.         return $this;
  264.     }
  266.     public function getEmail(): ?string
  267.     {
  268.         return $this->email;
  269.     }
  271.     public function setEmail(?string $email): self
  272.     {
  273.         $this->email = $email;
  275.         return $this;
  276.     }
  278.     public function getPhone(): ?string
  279.     {
  280.         return $this->phone;
  281.     }
  283.     public function setPhone(?string $phone): self
  284.     {
  285.         $this->phone = $phone;
  287.         return $this;
  288.     }
  290.     public function getPhoto(): ?string
  291.     {
  292.         return $this->photo;
  293.     }
  295.     public function setPhoto(?string $photo): self
  296.     {
  297.         $this->photo = $photo;
  299.         return $this;
  300.     }
  302.     public function isActive(): ?bool
  303.     {
  304.         return $this->isActive;
  305.     }
  307.     public function setIsActive(bool $isActive): self
  308.     {
  309.         $this->isActive = $isActive;
  311.         return $this;
  312.     }
  314.     /**
  315.      * A visual identifier that represents this user.
  316.      *
  317.      * @see UserInterface
  318.      */
  319.     public function getUserIdentifier(): string
  320.     {
  321.         return (string) $this->email;
  322.     }
  324.     /**
  325.      * @see UserInterface
  326.      */
  327.     public function getRoles(): array
  328.     {
  329.         $roles = $this->roles;
  330.         // guarantee every user at least has ROLE_USER
  331.         $roles[] = 'ROLE_CONSULTANT';
  333.         return array_unique($roles);
  334.     }
  336.     /**
  337.      * @see UserInterface
  338.      */
  339.     public function eraseCredentials()
  340.     {
  341.         // If you store any temporary, sensitive data on the user, clear it here
  342.         // $this->plainPassword = null;
  343.     }
  345.     public function setRoles(array $roles): self
  346.     {
  347.         $this->roles = $roles;
  349.         return $this;
  350.     }
  352.     public function getPassword(): ?string
  353.     {
  354.         return $this->password;
  355.     }
  357.     public function setPassword(string $password): self
  358.     {
  359.         $this->password = $password;
  361.         return $this;
  362.     }
  364.     public function getDepartment(): ?department
  365.     {
  366.         return $this->department;
  367.     }
  369.     public function setDepartment(?department $department): self
  370.     {
  371.         $this->department = $department;
  373.         return $this;
  374.     }
  376.     /**
  377.      * @return Collection<int, Order>
  378.      */
  379.     public function getOrders(): Collection
  380.     {
  381.         return $this->orders;
  382.     }
  384.     public function addOrder(Order $order): self
  385.     {
  386.         if (!$this->orders->contains($order)) {
  387.             $this->orders->add($order);
  388.             $order->setConsultant($this);
  389.         }
  391.         return $this;
  392.     }
  394.     public function removeOrder(Order $order): self
  395.     {
  396.         if ($this->orders->removeElement($order)) {
  397.             // set the owning side to null (unless already changed)
  398.             if ($order->getConsultant() === $this) {
  399.                 $order->setConsultant(null);
  400.             }
  401.         }
  403.         return $this;
  404.     }
  406.     /**
  407.      * @return Collection<int, Customer>
  408.      */
  409.     public function getCustomers(): Collection
  410.     {
  411.         return $this->customers;
  412.     }
  414.     public function addCustomer(Customer $customer): static
  415.     {
  416.         if (!$this->customers->contains($customer)) {
  417.             $this->customers->add($customer);
  418.             $customer->setConsultant($this);
  419.         }
  421.         return $this;
  422.     }
  424.     public function removeCustomer(Customer $customer): static
  425.     {
  426.         if ($this->customers->removeElement($customer)) {
  427.             // set the owning side to null (unless already changed)
  428.             if ($customer->getConsultant() === $this) {
  429.                 $customer->setConsultant(null);
  430.             }
  431.         }
  433.         return $this;
  434.     }
  436.     /**
  437.      * @return Collection<int, Notification>
  438.      */
  439.     public function getNotifications(): Collection
  440.     {
  441.         return $this->notifications;
  442.     }
  444.     public function addNotification(Notification $notification): static
  445.     {
  446.         if (!$this->notifications->contains($notification)) {
  447.             $this->notifications->add($notification);
  448.             $notification->addConsultant($this);
  449.         }
  451.         return $this;
  452.     }
  454.     public function removeNotification(Notification $notification): static
  455.     {
  456.         if ($this->notifications->removeElement($notification)) {
  457.             $notification->removeConsultant($this);
  458.         }
  460.         return $this;
  461.     }
  463.     /**
  464.      * @return Collection<int, OrderNote>
  465.      */
  466.     public function getOrderNotes(): Collection
  467.     {
  468.         return $this->orderNotes;
  469.     }
  471.     public function addOrderNote(OrderNote $orderNote): static
  472.     {
  473.         if (!$this->orderNotes->contains($orderNote)) {
  474.             $this->orderNotes->add($orderNote);
  475.             $orderNote->setConsultant($this);
  476.         }
  478.         return $this;
  479.     }
  481.     public function removeOrderNote(OrderNote $orderNote): static
  482.     {
  483.         if ($this->orderNotes->removeElement($orderNote)) {
  484.             // set the owning side to null (unless already changed)
  485.             if ($orderNote->getConsultant() === $this) {
  486.                 $orderNote->setConsultant(null);
  487.             }
  488.         }
  490.         return $this;
  491.     }
  493.     /**
  494.      * @return Collection<int, Order>
  495.      */
  496.     public function getDividedOrders(): Collection
  497.     {
  498.         return $this->dividedOrders;
  499.     }
  501.     public function addDividedOrder(Order $dividedOrder): static
  502.     {
  503.         if (!$this->dividedOrders->contains($dividedOrder)) {
  504.             $this->dividedOrders->add($dividedOrder);
  505.             $dividedOrder->setOrderDividedConsultant($this);
  506.         }
  508.         return $this;
  509.     }
  511.     public function removeDividedOrder(Order $dividedOrder): static
  512.     {
  513.         if ($this->dividedOrders->removeElement($dividedOrder)) {
  514.             // set the owning side to null (unless already changed)
  515.             if ($dividedOrder->getOrderDividedConsultant() === $this) {
  516.                 $dividedOrder->setOrderDividedConsultant(null);
  517.             }
  518.         }
  520.         return $this;
  521.     }
  523.     /**
  524.      * @return Collection<int, OrderHistory>
  525.      */
  526.     public function getOrderHistories(): Collection
  527.     {
  528.         return $this->orderHistories;
  529.     }
  531.     public function addOrderHistory(OrderHistory $orderHistory): static
  532.     {
  533.         if (!$this->orderHistories->contains($orderHistory)) {
  534.             $this->orderHistories->add($orderHistory);
  535.             $orderHistory->setConsultant($this);
  536.         }
  538.         return $this;
  539.     }
  541.     public function removeOrderHistory(OrderHistory $orderHistory): static
  542.     {
  543.         if ($this->orderHistories->removeElement($orderHistory)) {
  544.             // set the owning side to null (unless already changed)
  545.             if ($orderHistory->getConsultant() === $this) {
  546.                 $orderHistory->setConsultant(null);
  547.             }
  548.         }
  550.         return $this;
  551.     }
  553.     public function getBonusPercentage(): ?int
  554.     {
  555.         return $this->bonusPercentage;
  556.     }
  558.     public function setBonusPercentage(int $bonusPercentage): static
  559.     {
  560.         $this->bonusPercentage = $bonusPercentage;
  562.         return $this;
  563.     }
  565.     /**
  566.      * @return Collection<int, ConsultantReward>
  567.      */
  568.     public function getConsultantRewards(): Collection
  569.     {
  570.         return $this->consultantRewards;
  571.     }
  573.     public function addConsultantReward(ConsultantReward $consultantReward): static
  574.     {
  575.         if (!$this->consultantRewards->contains($consultantReward)) {
  576.             $this->consultantRewards->add($consultantReward);
  577.             $consultantReward->setConsultant($this);
  578.         }
  580.         return $this;
  581.     }
  583.     public function removeConsultantReward(ConsultantReward $consultantReward): static
  584.     {
  585.         if ($this->consultantRewards->removeElement($consultantReward)) {
  586.             // set the owning side to null (unless already changed)
  587.             if ($consultantReward->getConsultant() === $this) {
  588.                 $consultantReward->setConsultant(null);
  589.             }
  590.         }
  592.         return $this;
  593.     }
  595.     /**
  596.      * @return Collection<int, CommercialOffer>
  597.      */
  598.     public function getCommercialOffers(): Collection
  599.     {
  600.         return $this->commercialOffers;
  601.     }
  603.     public function addCommercialOffer(CommercialOffer $commercialOffer): static
  604.     {
  605.         if (!$this->commercialOffers->contains($commercialOffer)) {
  606.             $this->commercialOffers->add($commercialOffer);
  607.             $commercialOffer->addAvailableForConsultant($this);
  608.         }
  610.         return $this;
  611.     }
  613.     public function removeCommercialOffer(CommercialOffer $commercialOffer): static
  614.     {
  615.         if ($this->commercialOffers->removeElement($commercialOffer)) {
  616.             $commercialOffer->removeAvailableForConsultant($this);
  617.         }
  619.         return $this;
  620.     }
  622.     /**
  623.      * @return Collection<int, WorkHistory>
  624.      */
  625.     public function getWorkHistories(): Collection
  626.     {
  627.         return $this->workHistories;
  628.     }
  630.     public function addWorkHistory(WorkHistory $workHistory): static
  631.     {
  632.         if (!$this->workHistories->contains($workHistory)) {
  633.             $this->workHistories->add($workHistory);
  634.             $workHistory->setConsultant($this);
  635.         }
  637.         return $this;
  638.     }
  640.     public function removeWorkHistory(WorkHistory $workHistory): static
  641.     {
  642.         if ($this->workHistories->removeElement($workHistory)) {
  643.             // set the owning side to null (unless already changed)
  644.             if ($workHistory->getConsultant() === $this) {
  645.                 $workHistory->setConsultant(null);
  646.             }
  647.         }
  649.         return $this;
  650.     }
  652.     /**
  653.      * @return Collection<int, CommercialOfferIndividual>
  654.      */
  655.     public function getIndividualCommercialOffers(): Collection
  656.     {
  657.         return $this->commercialOfferIndividuals;
  658.     }
  660.     public function addIndividualCommercialOffer(CommercialOfferIndividual $commercialOfferIndividual): static
  661.     {
  662.         if (!$this->commercialOfferIndividuals->contains($commercialOfferIndividual)) {
  663.             $this->commercialOfferIndividuals->add($commercialOfferIndividual);
  664.             $commercialOfferIndividual->setCreatedByConsultant($this);
  665.         }
  667.         return $this;
  668.     }
  670.     public function removeIndividualCommercialOffer(CommercialOfferIndividual $commercialOfferIndividual): static
  671.     {
  672.         if ($this->commercialOfferIndividuals->removeElement($commercialOfferIndividual)) {
  673.             // set the owning side to null (unless already changed)
  674.             if ($commercialOfferIndividual->getCreatedByConsultant() === $this) {
  675.                 $commercialOfferIndividual->setCreatedByConsultant(null);
  676.             }
  677.         }
  679.         return $this;
  680.     }
  682.     /**
  683.      * @return Collection<int, CommercialOfferSendings>
  684.      */
  685.     public function getCommercialOfferSendings(): Collection
  686.     {
  687.         return $this->commercialOfferSendings;
  688.     }
  690.     public function addCommercialOfferSending(CommercialOfferSendings $commercialOfferSending): static
  691.     {
  692.         if (!$this->commercialOfferSendings->contains($commercialOfferSending)) {
  693.             $this->commercialOfferSendings->add($commercialOfferSending);
  694.             $commercialOfferSending->setAddedByConsultant($this);
  695.         }
  697.         return $this;
  698.     }
  700.     public function removeCommercialOfferSending(CommercialOfferSendings $commercialOfferSending): static
  701.     {
  702.         if ($this->commercialOfferSendings->removeElement($commercialOfferSending)) {
  703.             // set the owning side to null (unless already changed)
  704.             if ($commercialOfferSending->getAddedByConsultant() === $this) {
  705.                 $commercialOfferSending->setAddedByConsultant(null);
  706.             }
  707.         }
  709.         return $this;
  710.     }
  712.     /**
  713.      * @return Collection<int, DirectMessage>
  714.      */
  715.     public function getDirectMessagesSent(): Collection
  716.     {
  717.         return $this->directMessagesSent;
  718.     }
  720.     public function addDirectMessagesSent(DirectMessage $directMessagesSent): static
  721.     {
  722.         if (!$this->directMessagesSent->contains($directMessagesSent)) {
  723.             $this->directMessagesSent->add($directMessagesSent);
  724.             $directMessagesSent->setSenderConsultant($this);
  725.         }
  727.         return $this;
  728.     }
  730.     public function removeDirectMessagesSent(DirectMessage $directMessagesSent): static
  731.     {
  732.         if ($this->directMessagesSent->removeElement($directMessagesSent)) {
  733.             // set the owning side to null (unless already changed)
  734.             if ($directMessagesSent->getSenderConsultant() === $this) {
  735.                 $directMessagesSent->setSenderConsultant(null);
  736.             }
  737.         }
  739.         return $this;
  740.     }
  742.     /**
  743.      * @return Collection<int, DirectMessage>
  744.      */
  745.     public function getDirectMessagesReceived(): Collection
  746.     {
  747.         return $this->directMessagesReceived;
  748.     }
  750.     public function addDirectMessagesReceived(DirectMessage $directMessagesReceived): static
  751.     {
  752.         if (!$this->directMessagesReceived->contains($directMessagesReceived)) {
  753.             $this->directMessagesReceived->add($directMessagesReceived);
  754.             $directMessagesReceived->setReceiverConsultant($this);
  755.         }
  757.         return $this;
  758.     }
  760.     public function removeDirectMessagesReceived(DirectMessage $directMessagesReceived): static
  761.     {
  762.         if ($this->directMessagesReceived->removeElement($directMessagesReceived)) {
  763.             // set the owning side to null (unless already changed)
  764.             if ($directMessagesReceived->getReceiverConsultant() === $this) {
  765.                 $directMessagesReceived->setReceiverConsultant(null);
  766.             }
  767.         }
  769.         return $this;
  770.     }
  772.     public function isRemoteAccess(): ?bool
  773.     {
  774.         return $this->remoteAccess;
  775.     }
  777.     public function setRemoteAccess(bool $remoteAccess): static
  778.     {
  779.         $this->remoteAccess = $remoteAccess;
  781.         return $this;
  782.     }
  784.     /**
  785.      * @return Collection<int, Reservations>
  786.      */
  787.     public function getReservations(): Collection
  788.     {
  789.         return $this->reservations;
  790.     }
  792.     public function addReservation(Reservations $reservation): static
  793.     {
  794.         if (!$this->reservations->contains($reservation)) {
  795.             $this->reservations->add($reservation);
  796.             $reservation->setAddedByConsultant($this);
  797.         }
  799.         return $this;
  800.     }
  802.     public function removeReservation(Reservations $reservation): static
  803.     {
  804.         if ($this->reservations->removeElement($reservation)) {
  805.             // set the owning side to null (unless already changed)
  806.             if ($reservation->getAddedByConsultant() === $this) {
  807.                 $reservation->setAddedByConsultant(null);
  808.             }
  809.         }
  811.         return $this;
  812.     }
  814.     public function getColor(): ?string
  815.     {
  816.         return $this->color;
  817.     }
  819.     public function setColor(?string $color): static
  820.     {
  821.         $this->color = $color;
  823.         return $this;
  824.     }
  826.     /**
  827.      * @return Collection<int, DebtNote>
  828.      */
  829.     public function getDebtNotes(): Collection
  830.     {
  831.         return $this->debtNotes;
  832.     }
  834.     public function addDebtNote(DebtNote $debtNote): static
  835.     {
  836.         if (!$this->debtNotes->contains($debtNote)) {
  837.             $this->debtNotes->add($debtNote);
  838.             $debtNote->setConsultant($this);
  839.         }
  841.         return $this;
  842.     }
  844.     public function removeDebtNote(DebtNote $debtNote): static
  845.     {
  846.         if ($this->debtNotes->removeElement($debtNote)) {
  847.             // set the owning side to null (unless already changed)
  848.             if ($debtNote->getConsultant() === $this) {
  849.                 $debtNote->setConsultant(null);
  850.             }
  851.         }
  853.         return $this;
  854.     }
  856.     public function getOrderDivideds(): Collection
  857.     {
  858.         return $this->orderDivideds;
  859.     }
  861.     public function setOrderDivideds(Collection $orderDivideds): void
  862.     {
  863.         $this->orderDivideds = $orderDivideds;
  864.     }
  865.     public function removeOrderDivided(OrderDivided $orderDivided): static
  866.     {
  867.         if ($this->orderDivideds->removeElement($orderDivided)) {
  868.             // set the owning side to null (unless already changed)
  869.             if ($orderDivided->getConsultant() === $this) {
  870.                 $orderDivided->setConsultant(null);
  871.             }
  872.         }
  874.         return $this;
  875.     }
  877.     /**
  878.      * @return Collection<int, CustomerHistory>
  879.      */
  880.     public function getCustomerHistories(): Collection
  881.     {
  882.         return $this->customerHistories;
  883.     }
  885.     public function addCustomerHistory(CustomerHistory $customerHistory): static
  886.     {
  887.         if (!$this->customerHistories->contains($customerHistory)) {
  888.             $this->customerHistories->add($customerHistory);
  889.             $customerHistory->setConsultant($this);
  890.         }
  892.         return $this;
  893.     }
  895.     public function removeCustomerHistory(CustomerHistory $customerHistory): static
  896.     {
  897.         if ($this->customerHistories->removeElement($customerHistory)) {
  898.             // set the owning side to null (unless already changed)
  899.             if ($customerHistory->getConsultant() === $this) {
  900.                 $customerHistory->setConsultant(null);
  901.             }
  902.         }
  904.         return $this;
  905.     }
  907.     /**
  908.      * @return Collection<int, Awards>
  909.      */
  910.     public function getAwards(): Collection
  911.     {
  912.         return $this->awards;
  913.     }
  915.     public function addAward(Awards $award): static
  916.     {
  917.         if (!$this->awards->contains($award)) {
  918.             $this->awards->add($award);
  919.             $award->setConsultant($this);
  920.         }
  922.         return $this;
  923.     }
  925.     public function removeAward(Awards $award): static
  926.     {
  927.         if ($this->awards->removeElement($award)) {
  928.             // set the owning side to null (unless already changed)
  929.             if ($award->getConsultant() === $this) {
  930.                 $award->setConsultant(null);
  931.             }
  932.         }
  934.         return $this;
  935.     }
  937.     public function getAwardLeague(): ?AwardLeague
  938.     {
  939.         return $this->awardLeague;
  940.     }
  942.     public function setAwardLeague(?AwardLeague $awardLeague): static
  943.     {
  944.         $this->awardLeague = $awardLeague;
  946.         return $this;
  947.     }
  949.     /**
  950.      * @return Collection<int, AwardPtSum>
  951.      */
  952.     public function getAwardPtSums(): Collection
  953.     {
  954.         return $this->awardPtSums;
  955.     }
  957.     public function addAwardPtSum(AwardPtSum $awardPtSum): static
  958.     {
  959.         if (!$this->awardPtSums->contains($awardPtSum)) {
  960.             $this->awardPtSums->add($awardPtSum);
  961.             $awardPtSum->setConsultant($this);
  962.         }
  964.         return $this;
  965.     }
  967.     public function removeAwardPtSum(AwardPtSum $awardPtSum): static
  968.     {
  969.         if ($this->awardPtSums->removeElement($awardPtSum)) {
  970.             // set the owning side to null (unless already changed)
  971.             if ($awardPtSum->getConsultant() === $this) {
  972.                 $awardPtSum->setConsultant(null);
  973.             }
  974.         }
  976.         return $this;
  977.     }
  979.     /**
  980.      * @return Collection<int, AwardsDraw>
  981.      */
  982.     public function getAwardsDraws(): Collection
  983.     {
  984.         return $this->awardsDraws;
  985.     }
  987.     public function addAwardsDraw(AwardsDraw $awardsDraw): static
  988.     {
  989.         if (!$this->awardsDraws->contains($awardsDraw)) {
  990.             $this->awardsDraws->add($awardsDraw);
  991.             $awardsDraw->setConsultant($this);
  992.         }
  994.         return $this;
  995.     }
  997.     public function removeAwardsDraw(AwardsDraw $awardsDraw): static
  998.     {
  999.         if ($this->awardsDraws->removeElement($awardsDraw)) {
  1000.             // set the owning side to null (unless already changed)
  1001.             if ($awardsDraw->getConsultant() === $this) {
  1002.                 $awardsDraw->setConsultant(null);
  1003.             }
  1004.         }
  1006.         return $this;
  1007.     }
  1009.     public function isInAwards(): bool
  1010.     {
  1011.         return $this->inAwards;
  1012.     }
  1014.     public function setInAwards(bool $inAwards): static
  1015.     {
  1016.         $this->inAwards = $inAwards;
  1018.         return $this;
  1019.     }
  1021.     /**
  1022.      * @return Collection<int, Order>
  1023.      */
  1024.     public function getOrdersToNotes(): Collection
  1025.     {
  1026.         return $this->ordersToNotes;
  1027.     }
  1029.     public function addOrdersToNote(Order $ordersToNote): static
  1030.     {
  1031.         if (!$this->ordersToNotes->contains($ordersToNote)) {
  1032.             $this->ordersToNotes->add($ordersToNote);
  1033.             $ordersToNote->addConsultantForNote($this);
  1034.         }
  1036.         return $this;
  1037.     }
  1039.     public function removeOrdersToNote(Order $ordersToNote): static
  1040.     {
  1041.         if ($this->ordersToNotes->removeElement($ordersToNote)) {
  1042.             $ordersToNote->removeConsultantForNote($this);
  1043.         }
  1045.         return $this;
  1046.     }
  1048.     /**
  1049.      * @return Collection<int, SmsHistory>
  1050.      */
  1051.     public function getSmsHistories(): Collection
  1052.     {
  1053.         return $this->smsHistories;
  1054.     }
  1056.     public function addSmsHistory(SmsHistory $smsHistory): static
  1057.     {
  1058.         if (!$this->smsHistories->contains($smsHistory)) {
  1059.             $this->smsHistories->add($smsHistory);
  1060.             $smsHistory->setSendByConsultant($this);
  1061.         }
  1063.         return $this;
  1064.     }
  1066.     public function removeSmsHistory(SmsHistory $smsHistory): static
  1067.     {
  1068.         if ($this->smsHistories->removeElement($smsHistory)) {
  1069.             // set the owning side to null (unless already changed)
  1070.             if ($smsHistory->getSendByConsultant() === $this) {
  1071.                 $smsHistory->setSendByConsultant(null);
  1072.             }
  1073.         }
  1075.         return $this;
  1076.     }
  1078.     public function getNominalWorkTime(): ?NominalWorkTime
  1079.     {
  1080.         return $this->nominalWorkTime;
  1081.     }
  1083.     public function setNominalWorkTime(?NominalWorkTime $nominalWorkTime): static
  1084.     {
  1085.         // unset the owning side of the relation if necessary
  1086.         if ($nominalWorkTime === null && $this->nominalWorkTime !== null) {
  1087.             $this->nominalWorkTime->setConsultant(null);
  1088.         }
  1090.         // set the owning side of the relation if necessary
  1091.         if ($nominalWorkTime !== null && $nominalWorkTime->getConsultant() !== $this) {
  1092.             $nominalWorkTime->setConsultant($this);
  1093.         }
  1095.         $this->nominalWorkTime = $nominalWorkTime;
  1097.         return $this;
  1098.     }
  1100.     /**
  1101.      * @return Collection<int, WorkTime>
  1102.      */
  1103.     public function getWorkTimes(): Collection
  1104.     {
  1105.         return $this->workTimes;
  1106.     }
  1108.     public function addWorkTime(WorkTime $workTime): static
  1109.     {
  1110.         if (!$this->workTimes->contains($workTime)) {
  1111.             $this->workTimes->add($workTime);
  1112.             $workTime->setConsultant($this);
  1113.         }
  1115.         return $this;
  1116.     }
  1118.     public function removeWorkTime(WorkTime $workTime): static
  1119.     {
  1120.         if ($this->workTimes->removeElement($workTime)) {
  1121.             // set the owning side to null (unless already changed)
  1122.             if ($workTime->getConsultant() === $this) {
  1123.                 $workTime->setConsultant(null);
  1124.             }
  1125.         }
  1127.         return $this;
  1128.     }
  1130.     public function isRemoteWork(): ?bool
  1131.     {
  1132.         return $this->remoteWork;
  1133.     }
  1135.     public function setRemoteWork(bool $remoteWork): static
  1136.     {
  1137.         $this->remoteWork = $remoteWork;
  1139.         return $this;
  1140.     }
  1142.     /**
  1143.      * @return Collection<int, LeaveRequest>
  1144.      */
  1145.     public function getLeaveRequests(): Collection
  1146.     {
  1147.         return $this->leaveRequests;
  1148.     }
  1150.     public function addLeaveRequest(LeaveRequest $leaveRequest): static
  1151.     {
  1152.         if (!$this->leaveRequests->contains($leaveRequest)) {
  1153.             $this->leaveRequests->add($leaveRequest);
  1154.             $leaveRequest->setConsultant($this);
  1155.         }
  1157.         return $this;
  1158.     }
  1160.     public function removeLeaveRequest(LeaveRequest $leaveRequest): static
  1161.     {
  1162.         if ($this->leaveRequests->removeElement($leaveRequest)) {
  1163.             // set the owning side to null (unless already changed)
  1164.             if ($leaveRequest->getConsultant() === $this) {
  1165.                 $leaveRequest->setConsultant(null);
  1166.             }
  1167.         }
  1169.         return $this;
  1170.     }
  1172.     /**
  1173.      * @return Collection<int, EntityChangeLog>
  1174.      */
  1175.     public function getEntityChangeLogs(): Collection
  1176.     {
  1177.         return $this->entityChangeLogs;
  1178.     }
  1180.     public function addEntityChangeLog(EntityChangeLog $entityChangeLog): static
  1181.     {
  1182.         if (!$this->entityChangeLogs->contains($entityChangeLog)) {
  1183.             $this->entityChangeLogs->add($entityChangeLog);
  1184.             $entityChangeLog->setChangedByConsultant($this);
  1185.         }
  1187.         return $this;
  1188.     }
  1190.     public function removeEntityChangeLog(EntityChangeLog $entityChangeLog): static
  1191.     {
  1192.         if ($this->entityChangeLogs->removeElement($entityChangeLog)) {
  1193.             // set the owning side to null (unless already changed)
  1194.             if ($entityChangeLog->getChangedByConsultant() === $this) {
  1195.                 $entityChangeLog->setChangedByConsultant(null);
  1196.             }
  1197.         }
  1199.         return $this;
  1200.     }
  1202.     /**
  1203.      * @return Collection<int, SurveyResponse>
  1204.      */
  1205.     public function getSurveyResponses(): Collection
  1206.     {
  1207.         return $this->surveyResponses;
  1208.     }
  1210.     public function addSurveyResponse(SurveyResponse $surveyResponse): static
  1211.     {
  1212.         if (!$this->surveyResponses->contains($surveyResponse)) {
  1213.             $this->surveyResponses->add($surveyResponse);
  1214.             $surveyResponse->setMadeBy($this);
  1215.         }
  1217.         return $this;
  1218.     }
  1220.     public function removeSurveyResponse(SurveyResponse $surveyResponse): static
  1221.     {
  1222.         if ($this->surveyResponses->removeElement($surveyResponse)) {
  1223.             // set the owning side to null (unless already changed)
  1224.             if ($surveyResponse->getMadeBy() === $this) {
  1225.                 $surveyResponse->setMadeBy(null);
  1226.             }
  1227.         }
  1228.         return $this;
  1229.     }
  1230.     public function getPosition(): ?Position
  1231.     {
  1232.         return $this->position;
  1233.     }
  1235.     public function setPosition(?Position $position): static
  1236.     {
  1237.         $this->position = $position;
  1239.         return $this;
  1240.     }
  1242.     /**
  1243.      * @return Collection<int, ZoomList>
  1244.      */
  1245.     public function getZoomLists(): Collection
  1246.     {
  1247.         return $this->zoomLists;
  1248.     }
  1250.     public function addZoomList(ZoomList $zoomList): static
  1251.     {
  1252.         if (!$this->zoomLists->contains($zoomList)) {
  1253.             $this->zoomLists->add($zoomList);
  1254.             $zoomList->setConsultant($this);
  1255.         }
  1257.         return $this;
  1258.     }
  1260.     public function removeZoomList(ZoomList $zoomList): static
  1261.     {
  1262.         if ($this->zoomLists->removeElement($zoomList)) {
  1263.             // set the owning side to null (unless already changed)
  1264.             if ($zoomList->getConsultant() === $this) {
  1265.                 $zoomList->setConsultant(null);
  1266.             }
  1267.         }
  1269.         return $this;
  1270.     }
  1272.     public function getConsultantContractType(): ?EmploymentContractType
  1273.     {
  1274.         return $this->consultantContractType;
  1275.     }
  1277.     public function setConsultantContractType(?EmploymentContractType $consultantContractType): static
  1278.     {
  1279.         $this->consultantContractType = $consultantContractType;
  1281.         return $this;
  1282.     }
  1284.     /**
  1285.      * @return Collection<int, AccountingOfficeSendingNote>
  1286.      */
  1287.     public function getAccountingOfficeSendingNotes(): Collection
  1288.     {
  1289.         return $this->accountingOfficeSendingNotes;
  1290.     }
  1292.     public function addAccountingOfficeSendingNote(AccountingOfficeSendingNote $accountingOfficeSendingNote): static
  1293.     {
  1294.         if (!$this->accountingOfficeSendingNotes->contains($accountingOfficeSendingNote)) {
  1295.             $this->accountingOfficeSendingNotes->add($accountingOfficeSendingNote);
  1296.             $accountingOfficeSendingNote->setConsultant($this);
  1297.         }
  1299.         return $this;
  1300.     }
  1302.     public function removeAccountingOfficeSendingNote(AccountingOfficeSendingNote $accountingOfficeSendingNote): static
  1303.     {
  1304.         if ($this->accountingOfficeSendingNotes->removeElement($accountingOfficeSendingNote)) {
  1305.             // set the owning side to null (unless already changed)
  1306.             if ($accountingOfficeSendingNote->getConsultant() === $this) {
  1307.                 $accountingOfficeSendingNote->setConsultant(null);
  1308.             }
  1309.         }
  1311.         return $this;
  1312.     }
  1314.     public function isAcceptedRegulations(): ?bool
  1315.     {
  1316.         return $this->acceptedRegulations;
  1317.     }
  1319.     public function setAcceptedRegulations(bool $acceptedRegulations): static
  1320.     {
  1321.         $this->acceptedRegulations = $acceptedRegulations;
  1323.         return $this;
  1324.     }
  1326.     public function getAcceptedRegulationsDate(): ?\DateTimeInterface
  1327.     {
  1328.         return $this->acceptedRegulationsDate;
  1329.     }
  1331.     public function setAcceptedRegulationsDate(?\DateTimeInterface $acceptedRegulationsDate): static
  1332.     {
  1333.         $this->acceptedRegulationsDate = $acceptedRegulationsDate;
  1335.         return $this;
  1336.     }
  1338.     public function isAcceptedZfss(): ?bool
  1339.     {
  1340.         return $this->acceptedZfss;
  1341.     }
  1343.     public function setAcceptedZfss(bool $acceptedZfss): static
  1344.     {
  1345.         $this->acceptedZfss = $acceptedZfss;
  1347.         return $this;
  1348.     }
  1350.     public function getAcceptedZfssDate(): ?\DateTimeInterface
  1351.     {
  1352.         return $this->acceptedZfssDate;
  1353.     }
  1355.     public function setAcceptedZfssDate(\DateTimeInterface $acceptedZfssDate): static
  1356.     {
  1357.         $this->acceptedZfssDate = $acceptedZfssDate;
  1359.         return $this;
  1360.     }
  1362.     /**
  1363.      * @return Collection<int, LeaveRequestBalance>
  1364.      */
  1365.     public function getLeaveRequestBalances(): Collection
  1366.     {
  1367.         return $this->leaveRequestBalances;
  1368.     }
  1370.     public function addLeaveRequestBalance(LeaveRequestBalance $leaveRequestBalance): static
  1371.     {
  1372.         if (!$this->leaveRequestBalances->contains($leaveRequestBalance)) {
  1373.             $this->leaveRequestBalances->add($leaveRequestBalance);
  1374.             $leaveRequestBalance->setConsultant($this);
  1375.         }
  1377.         return $this;
  1378.     }
  1380.     public function removeLeaveRequestBalance(LeaveRequestBalance $leaveRequestBalance): static
  1381.     {
  1382.         if ($this->leaveRequestBalances->removeElement($leaveRequestBalance)) {
  1383.             // set the owning side to null (unless already changed)
  1384.             if ($leaveRequestBalance->getConsultant() === $this) {
  1385.                 $leaveRequestBalance->setConsultant(null);
  1386.             }
  1387.         }
  1389.         return $this;
  1390.     }
  1391. }