src/Entity/CRM/Admin.php line 30

  1. <?php
  3. namespace App\Entity\CRM;
  5. use App\Entity\CRM\Notification;
  6. use App\Entity\CRM\NotificationToSendSetting;
  7. use App\Entity\CRM\Order;
  8. use App\Entity\CRM\OrderHistory;
  9. use App\Entity\CRM\OrderNote;
  10. use App\Entity\CRM\Position;
  11. use App\Entity\CRM\Product;
  12. use App\Entity\CRM\Reservations;
  13. use App\Entity\CRM\SmsHistory;
  14. use App\Entity\CRM\Task;
  15. use App\Entity\CRM\Worker;
  16. use App\Entity\CRM\WorkHistory;
  17. use App\Repository\AdminRepository;
  18. use Doctrine\Common\Collections\ArrayCollection;
  19. use Doctrine\Common\Collections\Collection;
  20. use Doctrine\DBAL\Types\Types;
  21. use Doctrine\ORM\Mapping as ORM;
  22. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  23. use Symfony\Component\Security\Core\User\EquatableInterface;
  24. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  25. use Symfony\Component\Security\Core\User\UserInterface;
  27. #[ORM\Entity(repositoryClass: AdminRepository::class)]
  28. #[ORM\Table(name: '`admin`')]
  29. #[UniqueEntity(fields: ['email'], message: 'Konto o takim adresie email już istnieje')]
  30. class Admin implements UserInterface, PasswordAuthenticatedUserInterface, EquatableInterface
  31. {
  32.     #[ORM\Id]
  33.     #[ORM\GeneratedValue]
  34.     #[ORM\Column]
  35.     private ?int $id = null;
  37.     #[ORM\Column(length: 180, unique: true)]
  38.     private ?string $email = null;
  40.     #[ORM\Column(type: "string", nullable: false)]
  41.     private string $firstName;
  43.     #[ORM\Column(type: "string", nullable: false)]
  44.     private string $lastName;
  47.     #[ORM\Column(type: "boolean", nullable: false)]
  48.     private bool $isActive = true;
  50.     #[ORM\Column]
  51.     private array $roles = [];
  54.     /**
  55.      * @var string The hashed password
  56.      */
  57.     #[ORM\Column]
  58.     private string $password;
  60.     #[ORM\ManyToMany(targetEntity: Branch::class, inversedBy: 'admins')]
  61.     #[ORM\JoinColumn(nullable: false)]
  62.     private Collection $branches;
  64.     #[ORM\OneToOne(mappedBy: 'admin')]
  65.     private ?Worker $worker = null;
  67.     #[ORM\OneToOne(mappedBy: 'admin', cascade: ['persist', 'remove'])]
  68.     private ?Implementer $implementer = null;
  70.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: OrderHistory::class)]
  71.     private Collection $orderHistories;
  73.     #[ORM\Column(length: 255, nullable: true)]
  74.     private ?string $color = null;
  76.     #[ORM\ManyToMany(targetEntity: Notification::class, mappedBy: 'admin')]
  77.     private Collection $notifications;
  79.     #[ORM\Column(length: 6, nullable: true)]
  80.     private ?string $adminCode;
  82.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: OrderNote::class)]
  83.     private Collection $orderNotes;
  85.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: ImplementerOrderHistory::class)]
  86.     private Collection $implementerOrderHistories;
  88.     #[ORM\OneToMany(mappedBy: 'lastEditedBy', targetEntity: OrderNote::class)]
  89.     private Collection $orderEditedNotes;
  91.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: Order::class)]
  92.     private Collection $orders;
  94.     #[ORM\OneToMany(mappedBy: 'addedBy', targetEntity: CommercialOffer::class)]
  95.     private Collection $commercialOffers;
  97.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: WorkHistory::class)]
  98.     private Collection $workHistories;
  100.     #[ORM\OneToMany(mappedBy: 'createdByAdmin', targetEntity: CommercialOfferIndividual::class)]
  101.     private Collection $commercialOfferIndividuals;
  103.     #[ORM\OneToMany(mappedBy: 'addedByAdmin', targetEntity: CommercialOfferSendings::class)]
  104.     private Collection $commercialOfferSendings;
  106. //    #[ORM\OneToMany(mappedBy: 'acceptedBy', targetEntity: CommercialOfferSendings::class)]
  107. //    private Collection $commercialOfferSendingsAccepts;
  108. //
  109. //    #[ORM\OneToMany(mappedBy: 'acceptedBy', targetEntity: CommercialOfferIndividual::class)]
  110. //    private Collection $commercialOfferIndividualsAccepted;
  112.     #[ORM\OneToMany(mappedBy: 'addedByAdmin', targetEntity: Reservations::class)]
  113.     private Collection $reservations;
  115.     #[ORM\OneToMany(mappedBy: 'lastEditedBy', targetEntity: Reservations::class)]
  116.     private Collection $reservationsEdit;
  118.     #[ORM\OneToMany(mappedBy: 'senderAdmin', targetEntity: DirectMessage::class)]
  119.     private Collection $directMessagesSent;
  121.     #[ORM\OneToMany(mappedBy: 'receiverAdmin', targetEntity: DirectMessage::class)]
  122.     private Collection $directMessagesReceived;
  124.     #[ORM\Column]
  125.     private ?bool $remoteAccess = null;
  127.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: AdminNotificationSettings::class)]
  128.     private Collection $adminNotificationSettings;
  130.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: DebtNote::class)]
  131.     private Collection $debtNotes;
  133.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: CustomerHistory::class)]
  134.     private Collection $customerHistories;
  136.     #[ORM\Column(length: 255, nullable: true)]
  137.     private ?string $photo = null;
  139.     #[ORM\Column]
  140.     private bool $sendMail = true;
  142.     #[ORM\ManyToMany(targetEntity: Product::class, mappedBy: 'adminToInfo')]
  143.     private Collection $products;
  145.     #[ORM\OneToMany(mappedBy: 'sendByAdmin', targetEntity: SmsHistory::class)]
  146.     private Collection $smsHistories;
  148.     #[ORM\ManyToMany(targetEntity: NotificationToSendSetting::class, mappedBy: 'admin')]
  149.     private Collection $notificationToSendSettings;
  151.     #[ORM\OneToOne(mappedBy: 'admin', cascade: ['persist', 'remove'])]
  152.     private ?Mailbox $mailbox = null;
  154.     #[ORM\OneToMany(mappedBy: 'acceptedBy', targetEntity: LeaveRequest::class)]
  155.     private Collection $acceptedLeaveRequests;
  157.     #[ORM\OneToMany(mappedBy: 'rejectedBy', targetEntity: LeaveRequest::class)]
  158.     private Collection $rejectedLeaveRequests;
  161.     #[ORM\OneToMany(mappedBy: 'acceptedBy', targetEntity: Task::class)]
  162.     private Collection $acceptedTasks;
  164.     #[ORM\ManyToOne(inversedBy: 'admins')]
  165.     private ?Position $position = null;
  167.     #[ORM\ManyToMany(targetEntity: Agreement::class, mappedBy: 'agreementToSendAfterSigned')]
  168.     private Collection $agreementsToSendAfterSigned;
  170.     #[ORM\OneToOne(mappedBy: 'admin', cascade: ['persist', 'remove'])]
  171.     private ?NominalWorkTime $nominalWorkTime = null;
  173.     #[ORM\Column]
  174.     private bool $toRcp = true;
  176.     #[ORM\OneToMany(mappedBy: 'acceptedBy', targetEntity: WorkTime::class)]
  177.     private Collection $acceptedWorkTimes;
  179.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: AccountingOfficeSendingNote::class)]
  180.     private Collection $accountingOfficeSendingNotes;
  182.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: WorkTime::class)]
  183.     private Collection $workTimes;
  185.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: LeaveRequest::class)]
  186.     private Collection $leaveRequests;
  188.     #[ORM\ManyToMany(targetEntity: Department::class, mappedBy: 'management')]
  189.     private Collection $departments;
  191.     #[ORM\OneToMany(mappedBy: 'addedBy', targetEntity: NumberBlocking::class)]
  192.     private Collection $numberBlockings;
  194.     #[ORM\OneToMany(mappedBy: 'blockedBy', targetEntity: NumberBlocking::class)]
  195.     private Collection $numberBlockingsBlocked;
  197.     #[ORM\ManyToOne(inversedBy: 'admins')]
  198.     private ?AdminDepartment $adminDepartment = null;
  200.     #[ORM\Column]
  201.     private ?bool $acceptedRegulations = null;
  203.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  204.     private ?\DateTimeInterface $acceptedRegulationsDate = null;
  206.     #[ORM\Column]
  207.     private ?bool $acceptedZfss = null;
  209.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  210.     private ?\DateTimeInterface $acceptedZfssDate = null;
  212.     #[ORM\ManyToOne(inversedBy: 'admins')]
  213.     private ?EmploymentContractType $adminContractType = null;
  215.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: LeaveRequestBalance::class)]
  216.     private Collection $leaveRequestBalances;
  218.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  219.     private ?string $mailFooter = null;
  221.     public function __construct()
  222.     {
  223.         $this->branches = new ArrayCollection();
  224.         $this->orderHistories = new ArrayCollection();
  225.         $this->notifications = new ArrayCollection();
  226.         $this->adminCode = rand(000000, 999999);
  227.         $this->orderNotes = new ArrayCollection();
  228.         $this->implementerOrderHistories = new ArrayCollection();
  229.         $this->orderEditedNotes = new ArrayCollection();
  230.         $this->orders = new ArrayCollection();
  231.         $this->commercialOffers = new ArrayCollection();
  232.         $this->workHistories = new ArrayCollection();
  233.         $this->commercialOfferIndividuals = new ArrayCollection();
  234.         $this->commercialOfferSendings = new ArrayCollection();
  235.         $this->commercialOfferSendingsAccepts = new ArrayCollection();
  236.         $this->commercialOfferIndividualsAccepted = new ArrayCollection();
  237.         $this->reservations = new ArrayCollection();
  238.         $this->reservationsEdit = new ArrayCollection();
  239.         $this->directMessagesSent = new ArrayCollection();
  240.         $this->directMessagesReceived = new ArrayCollection();
  241.         $this->adminNotificationSettings = new ArrayCollection();
  242.         $this->debtNotes = new ArrayCollection();
  243.         $this->customerHistories = new ArrayCollection();
  244.         $this->products = new ArrayCollection();
  245.         $this->smsHistories = new ArrayCollection();
  246.         $this->notificationToSendSettings = new ArrayCollection();
  247.         $this->acceptedLeaveRequests = new ArrayCollection();
  248.         $this->rejectedLeaveRequests = new ArrayCollection();
  249.         $this->acceptedTasks = new ArrayCollection();
  250.         $this->position = null;
  251.         $this->agreementsToSendAfterSigned = new ArrayCollection();
  252.         $this->acceptedWorkTimes = new ArrayCollection();
  253.         $this->accountingOfficeSendingNotes = new ArrayCollection();
  254.         $this->workTimes = new ArrayCollection();
  255.         $this->leaveRequests = new ArrayCollection();
  256.         $this->departments = new ArrayCollection();
  257.         $this->numberBlockings = new ArrayCollection();
  258.         $this->numberBlockingsBlocked = new ArrayCollection();
  259.         $this->acceptedZfss = false;
  260.         $this->acceptedZfssDate = null;
  261.         $this->leaveRequestBalances = new ArrayCollection();
  262.     }
  264.     public function __toString()
  265.     {
  266.         return $this->firstName . ' ' . $this->lastName;
  267.     }
  269.     public function getFullName(): ?string
  270.     {
  271.         return $this->lastName.' '.$this->firstName;
  272.     }
  274.     public function getId(): ?int
  275.     {
  276.         return $this->id;
  277.     }
  279.     public function getEmail(): ?string
  280.     {
  281.         return $this->email;
  282.     }
  284.     public function setEmail(string $email): self
  285.     {
  286.         $this->email = $email;
  288.         return $this;
  289.     }
  291.     /**
  292.      * A visual identifier that represents this admin.
  293.      *
  294.      * @see UserInterface
  295.      */
  296.     public function getUserIdentifier(): string
  297.     {
  298.         return (string)$this->email;
  299.     }
  301.     /**
  302.      * @see UserInterface
  303.      */
  304.     public function getRoles(): array
  305.     {
  306.         $roles = $this->roles;
  307.         // guarantee every user at least has ROLE_USER
  308.         $roles[] = 'ROLE_USER';
  310.         return array_unique($roles);
  311.     }
  313.     public function setRoles(array $roles): self
  314.     {
  315.         $this->roles = $roles;
  317.         return $this;
  318.     }
  320.     /**
  321.      * @see PasswordAuthenticatedUserInterface
  322.      */
  323.     public function getPassword(): string
  324.     {
  325.         return $this->password;
  326.     }
  328.     public function setPassword(string $password): self
  329.     {
  330.         $this->password = $password;
  332.         return $this;
  333.     }
  335.     /**
  336.      * @return string
  337.      */
  338.     public function getFirstName(): string
  339.     {
  340.         return $this->firstName;
  341.     }
  343.     /**
  344.      * @param string $firstName
  345.      */
  346.     public function setFirstName(string $firstName): void
  347.     {
  348.         $this->firstName = $firstName;
  349.     }
  351.     /**
  352.      * @return string
  353.      */
  354.     public function getLastName(): string
  355.     {
  356.         return $this->lastName;
  357.     }
  359.     /**
  360.      * @param string $lastName
  361.      */
  362.     public function setLastName(string $lastName): void
  363.     {
  364.         $this->lastName = $lastName;
  365.     }
  368.     /**
  369.      * @return bool
  370.      */
  371.     public function isActive(): bool
  372.     {
  373.         return $this->isActive;
  374.     }
  376.     /**
  377.      * @param bool $isActive
  378.      */
  379.     public function setIsActive(bool $isActive): void
  380.     {
  381.         $this->isActive = $isActive;
  382.     }
  384.     /**
  385.      * @see UserInterface
  386.      */
  387.     public function eraseCredentials()
  388.     {
  389.         // If you store any temporary, sensitive data on the user, clear it here
  390.         // $this->plainPassword = null;
  391.     }
  393.     /**
  394.      * @return Collection
  395.      */
  396.     public function getBranches(): Collection
  397.     {
  398.         return $this->branches;
  399.     }
  401.     public function addBranch(Branch $branches): self
  402.     {
  403.         if (!$this->branches->contains($branches)) {
  404.             $this->branches[] = $branches;
  405.         }
  406.         return $this;
  407.     }
  409.     public function removeBranch(Branch $branches): self
  410.     {
  411.         $this->branches->removeElement($branches);
  412.         return $this;
  413.     }
  415.     public function getWorker(): ?Worker
  416.     {
  417.         return $this->worker;
  418.     }
  420.     public function setWorker(?Worker $worker): self
  421.     {
  422.         // unset the owning side of the relation if necessary
  423.         if ($worker === null && $this->worker !== null) {
  424.             $this->worker->setAdmin(null);
  425.         }
  427.         // set the owning side of the relation if necessary
  428.         if ($worker !== null && $worker->getAdmin() !== $this) {
  429.             $worker->setAdmin($this);
  430.         }
  432.         $this->worker = $worker;
  434.         return $this;
  435.     }
  437.     public function getImplementer(): ?Implementer
  438.     {
  439.         return $this->implementer;
  440.     }
  442.     public function setImplementer(Implementer $implementer): self
  443.     {
  444.         // set the owning side of the relation if necessary
  445.         if ($implementer->getAdmin() !== $this) {
  446.             $implementer->setAdmin($this);
  447.         }
  449.         $this->implementer = $implementer;
  451.         return $this;
  452.     }
  454.     /**
  455.      * @return Collection<int, OrderHistory>
  456.      */
  457.     public function getOrderHistories(): Collection
  458.     {
  459.         return $this->orderHistories;
  460.     }
  462.     public function addOrderHistory(OrderHistory $orderHistory): self
  463.     {
  464.         if (!$this->orderHistories->contains($orderHistory)) {
  465.             $this->orderHistories->add($orderHistory);
  466.             $orderHistory->setAdmin($this);
  467.         }
  469.         return $this;
  470.     }
  472.     public function removeOrderHistory(OrderHistory $orderHistory): self
  473.     {
  474.         if ($this->orderHistories->removeElement($orderHistory)) {
  475.             // set the owning side to null (unless already changed)
  476.             if ($orderHistory->getAdmin() === $this) {
  477.                 $orderHistory->setAdmin(null);
  478.             }
  479.         }
  481.         return $this;
  482.     }
  484.     // logs out the user when isActive status has been changed
  485.     public function isEqualTo(Admin|UserInterface $user): bool
  486.     {
  487.         if (!$user->isActive()) {
  488.             return false;
  489.         }
  490.         return true;
  491.     }
  493.     /**
  494.      * @return string|null
  495.      */
  496.     public function getColor(): ?string
  497.     {
  498.         return $this->color;
  499.     }
  501.     /**
  502.      * @param string|null $color
  503.      */
  504.     public function setColor(?string $color): void
  505.     {
  506.         $this->color = $color;
  507.     }
  509.     /**
  510.      * @return Collection<int, Notification>
  511.      */
  512.     public function getNotifications(): Collection
  513.     {
  514.         return $this->notifications;
  515.     }
  517.     public function addNotification(Notification $notification): static
  518.     {
  519.         if (!$this->notifications->contains($notification)) {
  520.             $this->notifications->add($notification);
  521.             $notification->addAdmin($this);
  522.         }
  524.         return $this;
  525.     }
  527.     public function removeNotification(Notification $notification): static
  528.     {
  529.         if ($this->notifications->removeElement($notification)) {
  530.             $notification->removeAdmin($this);
  531.         }
  533.         return $this;
  534.     }
  536.     public function getAdminCode(): ?string
  537.     {
  538.         return $this->adminCode;
  539.     }
  541.     public function setAdminCode(): static
  542.     {
  543.         $characters = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  544.         $code = '';
  546.         for ($i = 0; $i < 6; $i++) {
  547.             $code .= $characters[random_int(0, strlen($characters) - 1)];
  548.         }
  550.         $this->adminCode = $code;
  552.         return $this;
  553.     }
  555.     /**
  556.      * @return Collection<int, OrderNote>
  557.      */
  558.     public function getOrderNotes(): Collection
  559.     {
  560.         return $this->orderNotes;
  561.     }
  563.     public function addOrderNote(OrderNote $orderNote): static
  564.     {
  565.         if (!$this->orderNotes->contains($orderNote)) {
  566.             $this->orderNotes->add($orderNote);
  567.             $orderNote->setAdmin($this);
  568.         }
  570.         return $this;
  571.     }
  573.     public function removeOrderNote(OrderNote $orderNote): static
  574.     {
  575.         if ($this->orderNotes->removeElement($orderNote)) {
  576.             // set the owning side to null (unless already changed)
  577.             if ($orderNote->getAdmin() === $this) {
  578.                 $orderNote->setAdmin(null);
  579.             }
  580.         }
  582.         return $this;
  583.     }
  585.     /**
  586.      * @return Collection<int, ImplementerOrderHistory>
  587.      */
  588.     public
  589.     function getImplementerOrderHistories(): Collection
  590.     {
  591.         return $this->implementerOrderHistories;
  592.     }
  594.     public
  595.     function addImplementerOrderHistory(ImplementerOrderHistory $implementerOrderHistory): static
  596.     {
  597.         if (!$this->implementerOrderHistories->contains($implementerOrderHistory)) {
  598.             $this->implementerOrderHistories->add($implementerOrderHistory);
  599.             $implementerOrderHistory->setAdmin($this);
  600.         }
  602.         return $this;
  603.     }
  605.     public function removeImplementerOrderHistory(ImplementerOrderHistory $implementerOrderHistory): static
  606.     {
  607.         if ($this->implementerOrderHistories->removeElement($implementerOrderHistory)) {
  608.             // set the owning side to null (unless already changed)
  609.             if ($implementerOrderHistory->getAdmin() === $this) {
  610.                 $implementerOrderHistory->setAdmin(null);
  611.             }
  612.         }
  614.         return $this;
  615.     }
  617.     /**
  618.      * @return Collection<int, OrderNote>
  619.      */
  620.     public function getOrderEditedNotes(): Collection
  621.     {
  622.         return $this->orderEditedNotes;
  623.     }
  625.     public function addOrderEditedNote(OrderNote $orderEditedNote): static
  626.     {
  627.         if (!$this->orderEditedNotes->contains($orderEditedNote)) {
  628.             $this->orderEditedNotes->add($orderEditedNote);
  629.             $orderEditedNote->setLastEditedBy($this);
  630.         }
  632.         return $this;
  633.     }
  635.     public function removeOrderEditedNote(OrderNote $orderEditedNote): static
  636.     {
  637.         if ($this->orderEditedNotes->removeElement($orderEditedNote)) {
  638.             // set the owning side to null (unless already changed)
  639.             if ($orderEditedNote->getLastEditedBy() === $this) {
  640.                 $orderEditedNote->setLastEditedBy(null);
  641.             }
  642.         }
  644.         return $this;
  645.     }
  647.     /**
  648.      * @return Collection<int, Order>
  649.      */
  650.     public function getOrders(): Collection
  651.     {
  652.         return $this->orders;
  653.     }
  655.     public function addOrder(Order $order): static
  656.     {
  657.         if (!$this->orders->contains($order)) {
  658.             $this->orders->add($order);
  659.             $order->setAdmin($this);
  660.         }
  662.         return $this;
  663.     }
  665.     public function removeOrder(Order $order): static
  666.     {
  667.         if ($this->orders->removeElement($order)) {
  668.             // set the owning side to null (unless already changed)
  669.             if ($order->getAdmin() === $this) {
  670.                 $order->setAdmin(null);
  671.             }
  672.         }
  674.         return $this;
  675.     }
  677.     /**
  678.      * @return Collection<int, CommercialOffer>
  679.      */
  680.     public function getCommercialOffers(): Collection
  681.     {
  682.         return $this->commercialOffers;
  683.     }
  685.     public function addCommercialOffer(CommercialOffer $commercialOffer): static
  686.     {
  687.         if (!$this->commercialOffers->contains($commercialOffer)) {
  688.             $this->commercialOffers->add($commercialOffer);
  689.             $commercialOffer->setAddedBy($this);
  690.         }
  692.         return $this;
  693.     }
  695.     public function removeCommercialOffer(CommercialOffer $commercialOffer): static
  696.     {
  697.         if ($this->commercialOffers->removeElement($commercialOffer)) {
  698.             // set the owning side to null (unless already changed)
  699.             if ($commercialOffer->getAddedBy() === $this) {
  700.                 $commercialOffer->setAddedBy(null);
  701.             }
  702.         }
  704.         return $this;
  705.     }
  707.     /**
  708.      * @return Collection<int, WorkHistory>
  709.      */
  710.     public function getWorkHistories(): Collection
  711.     {
  712.         return $this->workHistories;
  713.     }
  715.     public function addWorkHistory(WorkHistory $workHistory): static
  716.     {
  717.         if (!$this->workHistories->contains($workHistory)) {
  718.             $this->workHistories->add($workHistory);
  719.             $workHistory->setAdmin($this);
  720.         }
  722.         return $this;
  723.     }
  725.     public function removeWorkHistory(WorkHistory $workHistory): static
  726.     {
  727.         if ($this->workHistories->removeElement($workHistory)) {
  728.             // set the owning side to null (unless already changed)
  729.             if ($workHistory->getAdmin() === $this) {
  730.                 $workHistory->setAdmin(null);
  731.             }
  732.         }
  734.         return $this;
  735.     }
  737.     /**
  738.      * @return Collection<int, CommercialOfferIndividual>
  739.      */
  740.     public function getCommercialOfferIndividuals(): Collection
  741.     {
  742.         return $this->commercialOfferIndividuals;
  743.     }
  745.     public function addCommercialOfferIndividual(CommercialOfferIndividual $commercialOfferIndividual): static
  746.     {
  747.         if (!$this->commercialOfferIndividuals->contains($commercialOfferIndividual)) {
  748.             $this->commercialOfferIndividuals->add($commercialOfferIndividual);
  749.             $commercialOfferIndividual->setCreatedByAdmin($this);
  750.         }
  752.         return $this;
  753.     }
  755.     public function removeCommercialOfferIndividual(CommercialOfferIndividual $commercialOfferIndividual): static
  756.     {
  757.         if ($this->commercialOfferIndividuals->removeElement($commercialOfferIndividual)) {
  758.             // set the owning side to null (unless already changed)
  759.             if ($commercialOfferIndividual->getCreatedByAdmin() === $this) {
  760.                 $commercialOfferIndividual->setCreatedByAdmin(null);
  761.             }
  762.         }
  764.         return $this;
  765.     }
  767.     /**
  768.      * @return Collection<int, CommercialOfferSendings>
  769.      */
  770.     public function getCommercialOfferSendings(): Collection
  771.     {
  772.         return $this->commercialOfferSendings;
  773.     }
  775.     public function addCommercialOfferSending(CommercialOfferSendings $commercialOfferSending): static
  776.     {
  777.         if (!$this->commercialOfferSendings->contains($commercialOfferSending)) {
  778.             $this->commercialOfferSendings->add($commercialOfferSending);
  779.             $commercialOfferSending->setAddedByAdmin($this);
  780.         }
  782.         return $this;
  783.     }
  785.     public function removeCommercialOfferSending(CommercialOfferSendings $commercialOfferSending): static
  786.     {
  787.         if ($this->commercialOfferSendings->removeElement($commercialOfferSending)) {
  788.             // set the owning side to null (unless already changed)
  789.             if ($commercialOfferSending->getAddedByAdmin() === $this) {
  790.                 $commercialOfferSending->setAddedByAdmin(null);
  791.             }
  792.         }
  794.         return $this;
  795.     }
  797.     /**
  798.      * @return Collection<int, CommercialOfferSendings>
  799.      */
  800.     public function getCommercialOfferSendingsAccepts(): Collection
  801.     {
  802.         return $this->commercialOfferSendingsAccepts;
  803.     }
  804.     /**
  805.      * @return Collection<int, CommercialOfferIndividual>
  806.      */
  807.     public function getCommercialOfferIndividualsAccepted(): Collection
  808.     {
  809.         return $this->commercialOfferIndividualsAccepted;
  810.     }
  812.     /**
  813.      * @return Collection<int, Reservations>
  814.      */
  815.     public function getReservations(): Collection
  816.     {
  817.         return $this->reservations;
  818.     }
  820.     public function addReservation(Reservations $reservation): static
  821.     {
  822.         if (!$this->reservations->contains($reservation)) {
  823.             $this->reservations->add($reservation);
  824.             $reservation->setAddedByAdmin($this);
  825.         }
  827.         return $this;
  828.     }
  830.     public function removeReservation(Reservations $reservation): static
  831.     {
  832.         if ($this->reservations->removeElement($reservation)) {
  833.             // set the owning side to null (unless already changed)
  834.             if ($reservation->getAddedByAdmin() === $this) {
  835.                 $reservation->setAddedByAdmin(null);
  836.             }
  837.         }
  839.         return $this;
  840.     }
  842.     /**
  843.      * @return Collection<int, Reservations>
  844.      */
  845.     public function getReservationsEdit(): Collection
  846.     {
  847.         return $this->reservationsEdit;
  848.     }
  850.     public function addReservationsEdit(Reservations $reservationsEdit): static
  851.     {
  852.         if (!$this->reservationsEdit->contains($reservationsEdit)) {
  853.             $this->reservationsEdit->add($reservationsEdit);
  854.             $reservationsEdit->setLastEditedBy($this);
  855.         }
  857.         return $this;
  858.     }
  860.     public function removeReservationsEdit(Reservations $reservationsEdit): static
  861.     {
  862.         if ($this->reservationsEdit->removeElement($reservationsEdit)) {
  863.             // set the owning side to null (unless already changed)
  864.             if ($reservationsEdit->getLastEditedBy() === $this) {
  865.                 $reservationsEdit->setLastEditedBy(null);
  866.             }
  867.         }
  869.         return $this;
  870.     }
  872.     /**
  873.      * @return Collection<int, DirectMessage>
  874.      */
  875.     public function getDirectMessagesSent(): Collection
  876.     {
  877.         return $this->directMessagesSent;
  878.     }
  880.     public function addDirectMessagesSent(DirectMessage $directMessagesSent): static
  881.     {
  882.         if (!$this->directMessagesSent->contains($directMessagesSent)) {
  883.             $this->directMessagesSent->add($directMessagesSent);
  884.             $directMessagesSent->setSenderAdmin($this);
  885.         }
  887.         return $this;
  888.     }
  890.     public function removeDirectMessagesSent(DirectMessage $directMessagesSent): static
  891.     {
  892.         if ($this->directMessagesSent->removeElement($directMessagesSent)) {
  893.             // set the owning side to null (unless already changed)
  894.             if ($directMessagesSent->getSenderAdmin() === $this) {
  895.                 $directMessagesSent->setSenderAdmin(null);
  896.             }
  897.         }
  899.         return $this;
  900.     }
  902.     /**
  903.      * @return Collection<int, DirectMessage>
  904.      */
  905.     public function getDirectMessagesReceived(): Collection
  906.     {
  907.         return $this->directMessagesReceived;
  908.     }
  910.     public function addDirectMessagesReceived(DirectMessage $directMessagesReceived): static
  911.     {
  912.         if (!$this->directMessagesReceived->contains($directMessagesReceived)) {
  913.             $this->directMessagesReceived->add($directMessagesReceived);
  914.             $directMessagesReceived->setReceiverAdmin($this);
  915.         }
  917.         return $this;
  918.     }
  920.     public function removeDirectMessagesReceived(DirectMessage $directMessagesReceived): static
  921.     {
  922.         if ($this->directMessagesReceived->removeElement($directMessagesReceived)) {
  923.             // set the owning side to null (unless already changed)
  924.             if ($directMessagesReceived->getReceiverAdmin() === $this) {
  925.                 $directMessagesReceived->setReceiverAdmin(null);
  926.             }
  927.         }
  929.         return $this;
  930.     }
  932.     public function isRemoteAccess(): ?bool
  933.     {
  934.         return $this->remoteAccess;
  935.     }
  937.     public function setRemoteAccess(bool $remoteAccess): static
  938.     {
  939.         $this->remoteAccess = $remoteAccess;
  941.         return $this;
  942.     }
  944.     /**
  945.      * @return Collection<int, AdminNotificationSettings>
  946.      */
  947.     public function getAdminNotificationSettings(): Collection
  948.     {
  949.         return $this->adminNotificationSettings;
  950.     }
  952.     public function addAdminNotificationSetting(AdminNotificationSettings $adminNotificationSetting): static
  953.     {
  954.         if (!$this->adminNotificationSettings->contains($adminNotificationSetting)) {
  955.             $this->adminNotificationSettings->add($adminNotificationSetting);
  956.             $adminNotificationSetting->setAdmin($this);
  957.         }
  959.         return $this;
  960.     }
  962.     public function removeAdminNotificationSetting(AdminNotificationSettings $adminNotificationSetting): static
  963.     {
  964.         if ($this->adminNotificationSettings->removeElement($adminNotificationSetting)) {
  965.             // set the owning side to null (unless already changed)
  966.             if ($adminNotificationSetting->getAdmin() === $this) {
  967.                 $adminNotificationSetting->setAdmin(null);
  968.             }
  969.         }
  971.         return $this;
  972.     }
  974.     /**
  975.      * @return Collection<int, DebtNote>
  976.      */
  977.     public function getDebtNotes(): Collection
  978.     {
  979.         return $this->debtNotes;
  980.     }
  982.     public function addDebtNote(DebtNote $debtNote): static
  983.     {
  984.         if (!$this->debtNotes->contains($debtNote)) {
  985.             $this->debtNotes->add($debtNote);
  986.             $debtNote->setAdmin($this);
  987.         }
  989.         return $this;
  990.     }
  992.     public function removeDebtNote(DebtNote $debtNote): static
  993.     {
  994.         if ($this->debtNotes->removeElement($debtNote)) {
  995.             // set the owning side to null (unless already changed)
  996.             if ($debtNote->getAdmin() === $this) {
  997.                 $debtNote->setAdmin(null);
  998.             }
  999.         }
  1001.         return $this;
  1002.     }
  1004.     /**
  1005.      * @return Collection<int, CustomerHistory>
  1006.      */
  1007.     public function getCustomerHistories(): Collection
  1008.     {
  1009.         return $this->customerHistories;
  1010.     }
  1012.     public function addCustomerHistory(CustomerHistory $customerHistory): static
  1013.     {
  1014.         if (!$this->customerHistories->contains($customerHistory)) {
  1015.             $this->customerHistories->add($customerHistory);
  1016.             $customerHistory->setAdmin($this);
  1017.         }
  1019.         return $this;
  1020.     }
  1022.     public function removeCustomerHistory(CustomerHistory $customerHistory): static
  1023.     {
  1024.         if ($this->customerHistories->removeElement($customerHistory)) {
  1025.             // set the owning side to null (unless already changed)
  1026.             if ($customerHistory->getAdmin() === $this) {
  1027.                 $customerHistory->setAdmin(null);
  1028.             }
  1029.         }
  1031.         return $this;
  1032.     }
  1034.     public function getPhoto(): ?string
  1035.     {
  1036.         return $this->photo;
  1037.     }
  1039.     public function setPhoto(?string $photo): static
  1040.     {
  1041.         $this->photo = $photo;
  1043.         return $this;
  1044.     }
  1046.     public function isSendMail(): bool
  1047.     {
  1048.         return $this->sendMail;
  1049.     }
  1051.     public function setSendMail(bool $sendMail): static
  1052.     {
  1053.         $this->sendMail = $sendMail;
  1055.         return $this;
  1056.     }
  1058.     /**
  1059.      * @return Collection<int, Product>
  1060.      */
  1061.     public function getProducts(): Collection
  1062.     {
  1063.         return $this->products;
  1064.     }
  1066.     public function addProduct(Product $product): static
  1067.     {
  1068.         if (!$this->products->contains($product)) {
  1069.             $this->products->add($product);
  1070.             $product->addAdminToInfo($this);
  1071.         }
  1073.         return $this;
  1074.     }
  1076.     public function removeProduct(Product $product): static
  1077.     {
  1078.         if ($this->products->removeElement($product)) {
  1079.             $product->removeAdminToInfo($this);
  1080.         }
  1082.         return $this;
  1083.     }
  1085.     /**
  1086.      * @return Collection<int, SmsHistory>
  1087.      */
  1088.     public function getSmsHistories(): Collection
  1089.     {
  1090.         return $this->smsHistories;
  1091.     }
  1093.     public function addSmsHistory(SmsHistory $smsHistory): static
  1094.     {
  1095.         if (!$this->smsHistories->contains($smsHistory)) {
  1096.             $this->smsHistories->add($smsHistory);
  1097.             $smsHistory->setSendByAdmin($this);
  1098.         }
  1100.         return $this;
  1101.     }
  1103.     public function removeSmsHistory(SmsHistory $smsHistory): static
  1104.     {
  1105.         if ($this->smsHistories->removeElement($smsHistory)) {
  1106.             // set the owning side to null (unless already changed)
  1107.             if ($smsHistory->getSendByAdmin() === $this) {
  1108.                 $smsHistory->setSendByAdmin(null);
  1109.             }
  1110.         }
  1112.         return $this;
  1113.     }
  1115.     /**
  1116.      * @return Collection<int, NotificationToSendSetting>
  1117.      */
  1118.     public function getNotificationToSendSettings(): Collection
  1119.     {
  1120.         return $this->notificationToSendSettings;
  1121.     }
  1123.     public function addNotificationToSendSetting(NotificationToSendSetting $notificationToSendSetting): static
  1124.     {
  1125.         if (!$this->notificationToSendSettings->contains($notificationToSendSetting)) {
  1126.             $this->notificationToSendSettings->add($notificationToSendSetting);
  1127.             $notificationToSendSetting->addAdmin($this);
  1128.         }
  1130.         return $this;
  1131.     }
  1133.     public function removeNotificationToSendSetting(NotificationToSendSetting $notificationToSendSetting): static
  1134.     {
  1135.         if ($this->notificationToSendSettings->removeElement($notificationToSendSetting)) {
  1136.             $notificationToSendSetting->removeAdmin($this);
  1137.         }
  1139.         return $this;
  1140.     }
  1142.     public function getMailbox(): ?Mailbox
  1143.     {
  1144.         return $this->mailbox;
  1145.     }
  1147.     public function setMailbox(?Mailbox $mailbox): static
  1148.     {
  1149.         // unset the owning side of the relation if necessary
  1150.         if ($mailbox === null && $this->mailbox !== null) {
  1151.             $this->mailbox->setAdmin(null);
  1152.         }
  1154.         // set the owning side of the relation if necessary
  1155.         if ($mailbox !== null && $mailbox->getAdmin() !== $this) {
  1156.             $mailbox->setAdmin($this);
  1157.         }
  1159.         $this->mailbox = $mailbox;
  1160.         return $this;
  1161.     }
  1163.     /**
  1164.      * @return Collection<int, LeaveRequest>
  1165.      */
  1166.     public function getAcceptedLeaveRequests(): Collection
  1167.     {
  1168.         return $this->acceptedLeaveRequests;
  1169.     }
  1171.     public function addAcceptedLeaveRequest(LeaveRequest $acceptedLeaveRequest): static
  1172.     {
  1173.         if (!$this->acceptedLeaveRequests->contains($acceptedLeaveRequest)) {
  1174.             $this->acceptedLeaveRequests->add($acceptedLeaveRequest);
  1175.             $acceptedLeaveRequest->setAcceptedBy($this);
  1176.         }
  1178.         return $this;
  1179.     }
  1181.     public function removeAcceptedLeaveRequest(LeaveRequest $acceptedLeaveRequest): static
  1182.     {
  1183.         if ($this->acceptedLeaveRequests->removeElement($acceptedLeaveRequest)) {
  1184.             // set the owning side to null (unless already changed)
  1185.             if ($acceptedLeaveRequest->getAcceptedBy() === $this) {
  1186.                 $acceptedLeaveRequest->setAcceptedBy(null);
  1187.             }
  1188.         }
  1190.         return $this;
  1191.     }
  1193.     /**
  1194.      * @return Collection<int, LeaveRequest>
  1195.      */
  1196.     public function getRejectedLeaveRequests(): Collection
  1197.     {
  1198.         return $this->rejectedLeaveRequests;
  1199.     }
  1201.     public function addRejectedLeaveRequest(LeaveRequest $rejectedLeaveRequest): static
  1202.     {
  1203.         if (!$this->rejectedLeaveRequests->contains($rejectedLeaveRequest)) {
  1204.             $this->rejectedLeaveRequests->add($rejectedLeaveRequest);
  1205.             $rejectedLeaveRequest->setRejectedBy($this);
  1206.         }
  1208.         return $this;
  1209.     }
  1211.     public function removeRejectedLeaveRequest(LeaveRequest $rejectedLeaveRequest): static
  1212.     {
  1213.         if ($this->rejectedLeaveRequests->removeElement($rejectedLeaveRequest)) {
  1214.             // set the owning side to null (unless already changed)
  1215.             if ($rejectedLeaveRequest->getRejectedBy() === $this) {
  1216.                 $rejectedLeaveRequest->setRejectedBy(null);
  1217.             }
  1218.         }
  1220.         return $this;
  1221.     }
  1223.     /**
  1224.      * @return Collection<int, Task>
  1225.      */
  1226.     public function getAcceptedTasks(): Collection
  1227.     {
  1228.         return $this->acceptedTasks;
  1229.     }
  1231.     public function addAcceptedTask(Task $acceptedTask): static
  1232.     {
  1233.         if (!$this->acceptedTasks->contains($acceptedTask)) {
  1234.             $this->acceptedTasks->add($acceptedTask);
  1235.             $acceptedTask->setAcceptedBy($this);
  1236.         }
  1238.         return $this;
  1239.     }
  1241.     public function removeAcceptedTask(Task $acceptedTask): static
  1242.     {
  1243.         if ($this->acceptedTasks->removeElement($acceptedTask)) {
  1244.             // set the owning side to null (unless already changed)
  1245.             if ($acceptedTask->getAcceptedBy() === $this) {
  1246.                 $acceptedTask->setAcceptedBy(null);
  1247.             }
  1248.         }
  1250.         return $this;
  1251.     }
  1253.     public function getPosition(): ?Position
  1254.     {
  1255.         return $this->position;
  1256.     }
  1258.     public function setPosition(?Position $position): static
  1259.     {
  1260.         $this->position = $position;
  1262.         return $this;
  1263.     }
  1265.     /**
  1266.      * @return Collection<int, Agreement>
  1267.      */
  1268.     public function getAgreementsToSendAfterSigned(): Collection
  1269.     {
  1270.         return $this->agreementsToSendAfterSigned;
  1271.     }
  1273.     public function addAgreementsToSendAfterSigned(Agreement $agreementsToSendAfterSigned): static
  1274.     {
  1275.         if (!$this->agreementsToSendAfterSigned->contains($agreementsToSendAfterSigned)) {
  1276.             $this->agreementsToSendAfterSigned->add($agreementsToSendAfterSigned);
  1277.             $agreementsToSendAfterSigned->addAgreementToSendAfterSigned($this);
  1278.         }
  1280.         return $this;
  1281.     }
  1283.     public function removeAgreementsToSendAfterSigned(Agreement $agreementsToSendAfterSigned): static
  1284.     {
  1285.         if ($this->agreementsToSendAfterSigned->removeElement($agreementsToSendAfterSigned)) {
  1286.             $agreementsToSendAfterSigned->removeAgreementToSendAfterSigned($this);
  1287.         }
  1289.         return $this;
  1290.     }
  1291.     /**
  1292.      * @return Collection<int, WorkTime>
  1293.      */
  1294.     public function getWorkTimes(): Collection
  1295.     {
  1296.         return $this->workTimes;
  1297.     }
  1299.     public function addWorkTime(WorkTime $workTime): static
  1300.     {
  1301.         if (!$this->workTimes->contains($workTime)) {
  1302.             $this->workTimes->add($workTime);
  1303.             $workTime->setAdminInstance($this);
  1304.         }
  1306.         return $this;
  1307.     }
  1309.     public function removeWorkTime(WorkTime $workTime): static
  1310.     {
  1311.         if ($this->workTimes->removeElement($workTime)) {
  1312.             // set the owning side to null (unless already changed)
  1313.             if ($workTime->getAdmin() === $this) {
  1314.                 $workTime->setAdmin(null);
  1315.             }
  1316.         }
  1318.         return $this;
  1319.     }
  1321.     public function getNominalWorkTime(): ?NominalWorkTime
  1322.     {
  1323.         return $this->nominalWorkTime;
  1324.     }
  1326.     public function setNominalWorkTime(?NominalWorkTime $nominalWorkTime): static
  1327.     {
  1328.         $this->nominalWorkTime = $nominalWorkTime;
  1330.         return $this;
  1331.     }
  1333.     /**
  1334.      * @return Collection<int, LeaveRequest>
  1335.      */
  1336.     public function getLeaveRequests(): Collection
  1337.     {
  1338.         return $this->leaveRequests;
  1339.     }
  1341.     public function addLeaveRequest(LeaveRequest $leaveRequest): static
  1342.     {
  1343.         if (!$this->leaveRequests->contains($leaveRequest)) {
  1344.             $this->leaveRequests->add($leaveRequest);
  1345.             $leaveRequest->setAdmin($this);
  1346.         }
  1348.         return $this;
  1349.     }
  1351.     public function removeLeaveRequest(LeaveRequest $leaveRequest): static
  1352.     {
  1353.         if ($this->leaveRequests->removeElement($leaveRequest)) {
  1354.             // set the owning side to null (unless already changed)
  1355.             if ($leaveRequest->getAdmin() === $this) {
  1356.                 $leaveRequest->setAdmin(null);
  1357.             }
  1358.         }
  1360.         return $this;
  1361.     }
  1363.     /**
  1364.      * @return Collection<int, AccountingOfficeSendingNote>
  1365.      */
  1366.     public function getAccountingOfficeSendingNotes(): Collection
  1367.     {
  1368.         return $this->accountingOfficeSendingNotes;
  1369.     }
  1371.     public function addAccountingOfficeSendingNote(AccountingOfficeSendingNote $accountingOfficeSendingNote): static
  1372.     {
  1373.         if (!$this->accountingOfficeSendingNotes->contains($accountingOfficeSendingNote)) {
  1374.             $this->accountingOfficeSendingNotes->add($accountingOfficeSendingNote);
  1375.             $accountingOfficeSendingNote->setAdmin($this);
  1376.         }
  1378.         return $this;
  1379.     }
  1381.     public function removeAccountingOfficeSendingNote(AccountingOfficeSendingNote $accountingOfficeSendingNote): static
  1382.     {
  1383.         if ($this->accountingOfficeSendingNotes->removeElement($accountingOfficeSendingNote)) {
  1384.             // set the owning side to null (unless already changed)
  1385.             if ($accountingOfficeSendingNote->getAdmin() === $this) {
  1386.                 $accountingOfficeSendingNote->setAdmin(null);
  1387.             }
  1388.         }
  1390.         return $this;
  1391.     }
  1393.     public function isToRcp(): bool
  1394.     {
  1395.         return $this->toRcp;
  1396.     }
  1398.     public function setToRcp(bool $toRcp): void
  1399.     {
  1400.         $this->toRcp = $toRcp;
  1401.     }
  1403.     /**
  1404.      * @return Collection<int, WorkTime>
  1405.      */
  1406.     public function getAcceptedWorkTimes(): Collection
  1407.     {
  1408.         return $this->acceptedWorkTimes;
  1409.     }
  1411.     public function addAcceptedWorkTime(WorkTime $acceptedWorkTime): static
  1412.     {
  1413.         if (!$this->acceptedWorkTimes->contains($acceptedWorkTime)) {
  1414.             $this->acceptedWorkTimes->add($acceptedWorkTime);
  1415.             $acceptedWorkTime->setAcceptedBy($this);
  1416.         }
  1418.         return $this;
  1419.     }
  1421.     public function removeAcceptedWorkTime(WorkTime $acceptedWorkTime): static
  1422.     {
  1423.         if ($this->acceptedWorkTimes->removeElement($acceptedWorkTime)) {
  1424.             // set the owning side to null (unless already changed)
  1425.             if ($acceptedWorkTime->getAcceptedBy() === $this) {
  1426.                 $acceptedWorkTime->setAcceptedBy(null);
  1427.             }
  1428.         }
  1430.         return $this;
  1431.     }
  1433.     /**
  1434.      * @return Collection<int, Department>
  1435.      */
  1436.     public function getDepartments(): Collection
  1437.     {
  1438.         return $this->departments;
  1439.     }
  1441.     public function addDepartment(Department $department): static
  1442.     {
  1443.         if (!$this->departments->contains($department)) {
  1444.             $this->departments->add($department);
  1445.             $department->addManagement($this);
  1446.         }
  1448.         return $this;
  1449.     }
  1451.     public function removeDepartment(Department $department): static
  1452.     {
  1453.         if ($this->departments->removeElement($department)) {
  1454.             $department->removeManagement($this);
  1455.         }
  1457.         return $this;
  1458.     }
  1460.     /** @return Collection<int, NumberBlocking> */
  1461.     public function getNumberBlockings(): Collection
  1462.     {
  1463.         return $this->numberBlockings;
  1464.     }
  1466.     public function addNumberBlocking(NumberBlocking $nb): self
  1467.     {
  1468.         if (!$this->numberBlockings->contains($nb)) {
  1469.             $this->numberBlockings->add($nb);
  1470.             $nb->setAddedBy($this);
  1471.         }
  1472.         return $this;
  1473.     }
  1475.     public function removeNumberBlocking(NumberBlocking $nb): self
  1476.     {
  1477.         if ($this->numberBlockings->removeElement($nb)) {
  1478.             if ($nb->getAddedBy() === $this) {
  1479.                 $nb->setAddedBy(null);
  1480.             }
  1481.         }
  1482.         return $this;
  1483.     }
  1485.     /** @return Collection<int, NumberBlocking> */
  1486.     public function getNumberBlockingsBlocked(): Collection
  1487.     {
  1488.         return $this->numberBlockingsBlocked;
  1489.     }
  1491.     public function addNumberBlockingBlocked(NumberBlocking $nb): self
  1492.     {
  1493.         if (!$this->numberBlockingsBlocked->contains($nb)) {
  1494.             $this->numberBlockingsBlocked->add($nb);
  1495.             $nb->setBlockedBy($this);
  1496.         }
  1497.         return $this;
  1498.     }
  1500.     public function removeNumberBlockingBlocked(NumberBlocking $nb): self
  1501.     {
  1502.         if ($this->numberBlockingsBlocked->removeElement($nb)) {
  1503.             if ($nb->getBlockedBy() === $this) {
  1504.                 $nb->setBlockedBy(null);
  1505.             }
  1506.         }
  1507.         return $this;
  1508.     }
  1510.     public function getAdminDepartment(): ?AdminDepartment
  1511.     {
  1512.         return $this->adminDepartment;
  1513.     }
  1515.     public function setAdminDepartment(?AdminDepartment $adminDepartment): static
  1516.     {
  1517.         $this->adminDepartment = $adminDepartment;
  1519.         return $this;
  1520.     }
  1522.     public function isAcceptedRegulations(): ?bool
  1523.     {
  1524.         return $this->acceptedRegulations;
  1525.     }
  1527.     public function setAcceptedRegulations(bool $acceptedRegulations): static
  1528.     {
  1529.         $this->acceptedRegulations = $acceptedRegulations;
  1531.         return $this;
  1532.     }
  1534.     public function getAcceptedRegulationsDate(): ?\DateTimeInterface
  1535.     {
  1536.         return $this->acceptedRegulationsDate;
  1537.     }
  1539.     public function setAcceptedRegulationsDate(?\DateTimeInterface $acceptedRegulationsDate): static
  1540.     {
  1541.         $this->acceptedRegulationsDate = $acceptedRegulationsDate;
  1543.         return $this;
  1544.     }
  1546.     public function isAcceptedZfss(): ?bool
  1547.     {
  1548.         return $this->acceptedZfss;
  1549.     }
  1551.     public function setAcceptedZfss(bool $acceptedZfss): static
  1552.     {
  1553.         $this->acceptedZfss = $acceptedZfss;
  1555.         return $this;
  1556.     }
  1558.     public function getAcceptedZfssDate(): ?\DateTimeInterface
  1559.     {
  1560.         return $this->acceptedZfssDate;
  1561.     }
  1563.     public function setAcceptedZfssDate(?\DateTimeInterface $acceptedZfssDate): static
  1564.     {
  1565.         $this->acceptedZfssDate = $acceptedZfssDate;
  1567.         return $this;
  1568.     }
  1570.     public function getAdminContractType(): ?EmploymentContractType
  1571.     {
  1572.         return $this->adminContractType;
  1573.     }
  1575.     public function setAdminContractType(?EmploymentContractType $adminContractType): static
  1576.     {
  1577.         $this->adminContractType = $adminContractType;
  1579.         return $this;
  1580.     }
  1582.     /**
  1583.      * @return Collection<int, LeaveRequestBalance>
  1584.      */
  1585.     public function getLeaveRequestBalances(): Collection
  1586.     {
  1587.         return $this->leaveRequestBalances;
  1588.     }
  1590.     public function addLeaveRequestBalance(LeaveRequestBalance $leaveRequestBalance): static
  1591.     {
  1592.         if (!$this->leaveRequestBalances->contains($leaveRequestBalance)) {
  1593.             $this->leaveRequestBalances->add($leaveRequestBalance);
  1594.             $leaveRequestBalance->setAdmin($this);
  1595.         }
  1597.         return $this;
  1598.     }
  1600.     public function removeLeaveRequestBalance(LeaveRequestBalance $leaveRequestBalance): static
  1601.     {
  1602.         if ($this->leaveRequestBalances->removeElement($leaveRequestBalance)) {
  1603.             // set the owning side to null (unless already changed)
  1604.             if ($leaveRequestBalance->getAdmin() === $this) {
  1605.                 $leaveRequestBalance->setAdmin(null);
  1606.             }
  1607.         }
  1609.         return $this;
  1610.     }
  1612.     public function getMailFooter(): ?string
  1613.     {
  1614.         return $this->mailFooter;
  1615.     }
  1617.     public function setMailFooter(?string $mailFooter): static
  1618.     {
  1619.         $this->mailFooter = $mailFooter;
  1621.         return $this;
  1622.     }
  1623. }