src/Entity/CRM/Admin.php line 19

  1. <?php
  3. namespace App\Entity\CRM;
  5. use App\Repository\AdminRepository;
  6. use DateTimeImmutable;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\EquatableInterface;
  13. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  14. use Symfony\Component\Security\Core\User\UserInterface;
  16. #[ORM\Entity(repositoryClass: AdminRepository::class)]
  17. #[ORM\Table(name: '`admin`')]
  18. #[UniqueEntity(fields: ['email'], message: 'Konto o takim adresie email już istnieje')]
  19. class Admin implements UserInterface, PasswordAuthenticatedUserInterface, EquatableInterface
  20. {
  21.     #[ORM\Id]
  22.     #[ORM\GeneratedValue]
  23.     #[ORM\Column]
  24.     private ?int $id = null;
  26.     #[ORM\Column(length: 180, unique: true)]
  27.     private ?string $email = null;
  29.     #[ORM\Column(type: "string", nullable: false)]
  30.     private string $firstName;
  32.     #[ORM\Column(type: "string", nullable: false)]
  33.     private string $lastName;
  35.     #[ORM\Column(length: 255, nullable: true)]
  36.     private ?string $phone = null;
  38.     #[ORM\Column(length: 64, nullable: true)]
  39.     private ?string $lineNumber = null;
  42.     #[ORM\Column(type: "boolean", nullable: false)]
  43.     private bool $isActive = true;
  45.     #[ORM\Column]
  46.     private array $roles = [];
  49.     /**
  50.      * @var string The hashed password
  51.      */
  52.     #[ORM\Column]
  53.     private string $password;
  55.     #[ORM\ManyToMany(targetEntity: Branch::class, inversedBy: 'admins')]
  56.     #[ORM\JoinColumn(nullable: false)]
  57.     private Collection $branches;
  59.     #[ORM\OneToOne(mappedBy: 'admin')]
  60.     private ?Worker $worker = null;
  62.     #[ORM\OneToOne(mappedBy: 'admin', cascade: ['persist', 'remove'])]
  63.     private ?Implementer $implementer = null;
  65.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: OrderHistory::class)]
  66.     private Collection $orderHistories;
  68.     #[ORM\Column(length: 255, nullable: true)]
  69.     private ?string $color = null;
  71.     #[ORM\ManyToMany(targetEntity: Notification::class, mappedBy: 'admin')]
  72.     private Collection $notifications;
  74.     #[ORM\Column(length: 6, nullable: true)]
  75.     private ?string $adminCode;
  77.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: OrderNote::class)]
  78.     private Collection $orderNotes;
  80.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: ImplementerOrderHistory::class)]
  81.     private Collection $implementerOrderHistories;
  83.     #[ORM\OneToMany(mappedBy: 'lastEditedBy', targetEntity: OrderNote::class)]
  84.     private Collection $orderEditedNotes;
  86.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: Order::class)]
  87.     private Collection $orders;
  89.     #[ORM\OneToMany(mappedBy: 'addedBy', targetEntity: CommercialOffer::class)]
  90.     private Collection $commercialOffers;
  92.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: WorkHistory::class)]
  93.     private Collection $workHistories;
  95.     #[ORM\OneToMany(mappedBy: 'createdByAdmin', targetEntity: CommercialOfferIndividual::class)]
  96.     private Collection $commercialOfferIndividuals;
  98.     #[ORM\OneToMany(mappedBy: 'addedByAdmin', targetEntity: CommercialOfferSendings::class)]
  99.     private Collection $commercialOfferSendings;
  101.     //    #[ORM\OneToMany(mappedBy: 'acceptedBy', targetEntity: CommercialOfferSendings::class)]
  102. //    private Collection $commercialOfferSendingsAccepts;
  103. //
  104. //    #[ORM\OneToMany(mappedBy: 'acceptedBy', targetEntity: CommercialOfferIndividual::class)]
  105. //    private Collection $commercialOfferIndividualsAccepted;
  107.     #[ORM\OneToMany(mappedBy: 'addedByAdmin', targetEntity: Reservations::class)]
  108.     private Collection $reservations;
  110.     #[ORM\OneToMany(mappedBy: 'lastEditedBy', targetEntity: Reservations::class)]
  111.     private Collection $reservationsEdit;
  113.     #[ORM\OneToMany(mappedBy: 'senderAdmin', targetEntity: DirectMessage::class)]
  114.     private Collection $directMessagesSent;
  116.     #[ORM\OneToMany(mappedBy: 'receiverAdmin', targetEntity: DirectMessage::class)]
  117.     private Collection $directMessagesReceived;
  119.     #[ORM\Column]
  120.     private ?bool $remoteAccess = null;
  122.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: AdminNotificationSettings::class)]
  123.     private Collection $adminNotificationSettings;
  125.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: DebtNote::class)]
  126.     private Collection $debtNotes;
  128.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: CustomerHistory::class)]
  129.     private Collection $customerHistories;
  131.     #[ORM\Column(length: 255, nullable: true)]
  132.     private ?string $photo = null;
  134.     #[ORM\Column]
  135.     private bool $sendMail = true;
  137.     #[ORM\ManyToMany(targetEntity: Product::class, mappedBy: 'adminToInfo')]
  138.     private Collection $products;
  140.     #[ORM\OneToMany(mappedBy: 'sendByAdmin', targetEntity: SmsHistory::class)]
  141.     private Collection $smsHistories;
  143.     #[ORM\ManyToMany(targetEntity: NotificationToSendSetting::class, mappedBy: 'admin')]
  144.     private Collection $notificationToSendSettings;
  146.     #[ORM\OneToOne(mappedBy: 'admin', cascade: ['persist', 'remove'])]
  147.     private ?Mailbox $mailbox = null;
  149.     #[ORM\OneToMany(mappedBy: 'acceptedBy', targetEntity: LeaveRequest::class)]
  150.     private Collection $acceptedLeaveRequests;
  152.     #[ORM\OneToMany(mappedBy: 'rejectedBy', targetEntity: LeaveRequest::class)]
  153.     private Collection $rejectedLeaveRequests;
  156.     #[ORM\OneToMany(mappedBy: 'acceptedBy', targetEntity: Task::class)]
  157.     private Collection $acceptedTasks;
  159.     #[ORM\ManyToOne(inversedBy: 'admins')]
  160.     private ?Position $position = null;
  162.     #[ORM\ManyToMany(targetEntity: Agreement::class, mappedBy: 'agreementToSendAfterSigned')]
  163.     private Collection $agreementsToSendAfterSigned;
  165.     #[ORM\OneToOne(mappedBy: 'admin', cascade: ['persist', 'remove'])]
  166.     private ?NominalWorkTime $nominalWorkTime = null;
  168.     #[ORM\Column]
  169.     private bool $toRcp = true;
  171.     #[ORM\OneToMany(mappedBy: 'acceptedBy', targetEntity: WorkTime::class)]
  172.     private Collection $acceptedWorkTimes;
  174.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: AccountingOfficeSendingNote::class)]
  175.     private Collection $accountingOfficeSendingNotes;
  177.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: WorkTime::class)]
  178.     private Collection $workTimes;
  180.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: LeaveRequest::class)]
  181.     private Collection $leaveRequests;
  183.     #[ORM\ManyToMany(targetEntity: Department::class, mappedBy: 'management')]
  184.     private Collection $departments;
  186.     #[ORM\OneToMany(mappedBy: 'addedBy', targetEntity: NumberBlocking::class)]
  187.     private Collection $numberBlockings;
  189.     #[ORM\OneToMany(mappedBy: 'blockedBy', targetEntity: NumberBlocking::class)]
  190.     private Collection $numberBlockingsBlocked;
  192.     #[ORM\ManyToOne(inversedBy: 'admins')]
  193.     private ?AdminDepartment $adminDepartment = null;
  195.     #[ORM\Column]
  196.     private ?bool $acceptedRegulations = null;
  198.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  199.     private ?\DateTimeInterface $acceptedRegulationsDate = null;
  201.     #[ORM\Column]
  202.     private ?bool $acceptedZfss = null;
  204.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  205.     private ?\DateTimeInterface $acceptedZfssDate = null;
  207.     #[ORM\ManyToOne(inversedBy: 'admins')]
  208.     private ?EmploymentContractType $adminContractType = null;
  210.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: LeaveRequestBalance::class)]
  211.     private Collection $leaveRequestBalances;
  213.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: AudioAsset::class)]
  214.     private Collection $audioAssets;
  216.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  217.     private ?string $mailFooter = null;
  219.     #[ORM\Column]
  220.     private bool $disability = false;
  222.     public function __construct()
  223.     {
  224.         $this->branches = new ArrayCollection();
  225.         $this->orderHistories = new ArrayCollection();
  226.         $this->notifications = new ArrayCollection();
  227.         $this->adminCode = rand(000000, 999999);
  228.         $this->orderNotes = new ArrayCollection();
  229.         $this->implementerOrderHistories = new ArrayCollection();
  230.         $this->orderEditedNotes = new ArrayCollection();
  231.         $this->orders = new ArrayCollection();
  232.         $this->commercialOffers = new ArrayCollection();
  233.         $this->workHistories = new ArrayCollection();
  234.         $this->commercialOfferIndividuals = new ArrayCollection();
  235.         $this->commercialOfferSendings = new ArrayCollection();
  236.         $this->commercialOfferSendingsAccepts = new ArrayCollection();
  237.         $this->commercialOfferIndividualsAccepted = new ArrayCollection();
  238.         $this->reservations = new ArrayCollection();
  239.         $this->reservationsEdit = new ArrayCollection();
  240.         $this->directMessagesSent = new ArrayCollection();
  241.         $this->directMessagesReceived = new ArrayCollection();
  242.         $this->adminNotificationSettings = new ArrayCollection();
  243.         $this->debtNotes = new ArrayCollection();
  244.         $this->customerHistories = new ArrayCollection();
  245.         $this->products = new ArrayCollection();
  246.         $this->smsHistories = new ArrayCollection();
  247.         $this->notificationToSendSettings = new ArrayCollection();
  248.         $this->acceptedLeaveRequests = new ArrayCollection();
  249.         $this->rejectedLeaveRequests = new ArrayCollection();
  250.         $this->acceptedTasks = new ArrayCollection();
  251.         $this->position = null;
  252.         $this->agreementsToSendAfterSigned = new ArrayCollection();
  253.         $this->acceptedWorkTimes = new ArrayCollection();
  254.         $this->accountingOfficeSendingNotes = new ArrayCollection();
  255.         $this->workTimes = new ArrayCollection();
  256.         $this->leaveRequests = new ArrayCollection();
  257.         $this->departments = new ArrayCollection();
  258.         $this->numberBlockings = new ArrayCollection();
  259.         $this->numberBlockingsBlocked = new ArrayCollection();
  260.         $this->acceptedZfss = false;
  261.         $this->acceptedZfssDate = null;
  262.         $this->leaveRequestBalances = new ArrayCollection();
  263.         $this->audioAssets = new ArrayCollection();
  264.     }
  266.     public function __toString()
  267.     {
  268.         return $this->firstName . ' ' . $this->lastName;
  269.     }
  271.     public function getFullName(): ?string
  272.     {
  273.         return $this->lastName . ' ' . $this->firstName;
  274.     }
  276.     public function getId(): ?int
  277.     {
  278.         return $this->id;
  279.     }
  281.     public function getEmail(): ?string
  282.     {
  283.         return $this->email;
  284.     }
  286.     public function setEmail(string $email): self
  287.     {
  288.         $this->email = $email;
  290.         return $this;
  291.     }
  293.     /**
  294.      * A visual identifier that represents this admin.
  295.      *
  296.      * @see UserInterface
  297.      */
  298.     public function getUserIdentifier(): string
  299.     {
  300.         return (string) $this->email;
  301.     }
  303.     /**
  304.      * @see UserInterface
  305.      */
  306.     public function getRoles(): array
  307.     {
  308.         $roles = $this->roles;
  309.         // guarantee every user at least has ROLE_USER
  310.         $roles[] = 'ROLE_USER';
  312.         return array_unique($roles);
  313.     }
  315.     public function setRoles(array $roles): self
  316.     {
  317.         $this->roles = $roles;
  319.         return $this;
  320.     }
  322.     /**
  323.      * @see PasswordAuthenticatedUserInterface
  324.      */
  325.     public function getPassword(): string
  326.     {
  327.         return $this->password;
  328.     }
  330.     public function setPassword(string $password): self
  331.     {
  332.         $this->password = $password;
  334.         return $this;
  335.     }
  337.     /**
  338.      * @return string
  339.      */
  340.     public function getFirstName(): string
  341.     {
  342.         return $this->firstName;
  343.     }
  345.     /**
  346.      * @param string $firstName
  347.      */
  348.     public function setFirstName(string $firstName): void
  349.     {
  350.         $this->firstName = $firstName;
  351.     }
  353.     /**
  354.      * @return string
  355.      */
  356.     public function getLastName(): string
  357.     {
  358.         return $this->lastName;
  359.     }
  361.     /**
  362.      * @param string $lastName
  363.      */
  364.     public function setLastName(string $lastName): void
  365.     {
  366.         $this->lastName = $lastName;
  367.     }
  369.     public function getPhone(): ?string
  370.     {
  371.         return $this->phone;
  372.     }
  374.     public function setPhone(?string $phone): self
  375.     {
  376.         $this->phone = $phone;
  378.         return $this;
  379.     }
  381.     public function getLineNumber(): ?string
  382.     {
  383.         return $this->lineNumber;
  384.     }
  386.     public function setLineNumber(?string $lineNumber): self
  387.     {
  388.         $this->lineNumber = $lineNumber;
  390.         return $this;
  391.     }
  394.     /**
  395.      * @return bool
  396.      */
  397.     public function isActive(): bool
  398.     {
  399.         return $this->isActive;
  400.     }
  402.     /**
  403.      * @param bool $isActive
  404.      */
  405.     public function setIsActive(bool $isActive): void
  406.     {
  407.         $this->isActive = $isActive;
  408.     }
  410.     /**
  411.      * @see UserInterface
  412.      */
  413.     public function eraseCredentials()
  414.     {
  415.         // If you store any temporary, sensitive data on the user, clear it here
  416.         // $this->plainPassword = null;
  417.     }
  419.     /**
  420.      * @return Collection
  421.      */
  422.     public function getBranches(): Collection
  423.     {
  424.         return $this->branches;
  425.     }
  427.     public function addBranch(Branch $branches): self
  428.     {
  429.         if (!$this->branches->contains($branches)) {
  430.             $this->branches[] = $branches;
  431.         }
  432.         return $this;
  433.     }
  435.     public function removeBranch(Branch $branches): self
  436.     {
  437.         $this->branches->removeElement($branches);
  438.         return $this;
  439.     }
  441.     public function getWorker(): ?Worker
  442.     {
  443.         return $this->worker;
  444.     }
  446.     public function setWorker(?Worker $worker): self
  447.     {
  448.         // unset the owning side of the relation if necessary
  449.         if ($worker === null && $this->worker !== null) {
  450.             $this->worker->setAdmin(null);
  451.         }
  453.         // set the owning side of the relation if necessary
  454.         if ($worker !== null && $worker->getAdmin() !== $this) {
  455.             $worker->setAdmin($this);
  456.         }
  458.         $this->worker = $worker;
  460.         return $this;
  461.     }
  463.     public function getImplementer(): ?Implementer
  464.     {
  465.         return $this->implementer;
  466.     }
  468.     public function setImplementer(Implementer $implementer): self
  469.     {
  470.         // set the owning side of the relation if necessary
  471.         if ($implementer->getAdmin() !== $this) {
  472.             $implementer->setAdmin($this);
  473.         }
  475.         $this->implementer = $implementer;
  477.         return $this;
  478.     }
  480.     /**
  481.      * @return Collection<int, OrderHistory>
  482.      */
  483.     public function getOrderHistories(): Collection
  484.     {
  485.         return $this->orderHistories;
  486.     }
  488.     public function addOrderHistory(OrderHistory $orderHistory): self
  489.     {
  490.         if (!$this->orderHistories->contains($orderHistory)) {
  491.             $this->orderHistories->add($orderHistory);
  492.             $orderHistory->setAdmin($this);
  493.         }
  495.         return $this;
  496.     }
  498.     public function removeOrderHistory(OrderHistory $orderHistory): self
  499.     {
  500.         if ($this->orderHistories->removeElement($orderHistory)) {
  501.             // set the owning side to null (unless already changed)
  502.             if ($orderHistory->getAdmin() === $this) {
  503.                 $orderHistory->setAdmin(null);
  504.             }
  505.         }
  507.         return $this;
  508.     }
  510.     // logs out the user when isActive status has been changed
  511.     public function isEqualTo(Admin|UserInterface $user): bool
  512.     {
  513.         if (!$user->isActive()) {
  514.             return false;
  515.         }
  516.         return true;
  517.     }
  519.     /**
  520.      * @return string|null
  521.      */
  522.     public function getColor(): ?string
  523.     {
  524.         return $this->color;
  525.     }
  527.     /**
  528.      * @param string|null $color
  529.      */
  530.     public function setColor(?string $color): void
  531.     {
  532.         $this->color = $color;
  533.     }
  535.     /**
  536.      * @return Collection<int, Notification>
  537.      */
  538.     public function getNotifications(): Collection
  539.     {
  540.         return $this->notifications;
  541.     }
  543.     public function addNotification(Notification $notification): static
  544.     {
  545.         if (!$this->notifications->contains($notification)) {
  546.             $this->notifications->add($notification);
  547.             $notification->addAdmin($this);
  548.         }
  550.         return $this;
  551.     }
  553.     public function removeNotification(Notification $notification): static
  554.     {
  555.         if ($this->notifications->removeElement($notification)) {
  556.             $notification->removeAdmin($this);
  557.         }
  559.         return $this;
  560.     }
  562.     public function getAdminCode(): ?string
  563.     {
  564.         return $this->adminCode;
  565.     }
  567.     public function setAdminCode(): static
  568.     {
  569.         $characters = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  570.         $code = '';
  572.         for ($i = 0; $i < 6; $i++) {
  573.             $code .= $characters[random_int(0, strlen($characters) - 1)];
  574.         }
  576.         $this->adminCode = $code;
  578.         return $this;
  579.     }
  581.     /**
  582.      * @return Collection<int, OrderNote>
  583.      */
  584.     public function getOrderNotes(): Collection
  585.     {
  586.         return $this->orderNotes;
  587.     }
  589.     public function addOrderNote(OrderNote $orderNote): static
  590.     {
  591.         if (!$this->orderNotes->contains($orderNote)) {
  592.             $this->orderNotes->add($orderNote);
  593.             $orderNote->setAdmin($this);
  594.         }
  596.         return $this;
  597.     }
  599.     public function removeOrderNote(OrderNote $orderNote): static
  600.     {
  601.         if ($this->orderNotes->removeElement($orderNote)) {
  602.             // set the owning side to null (unless already changed)
  603.             if ($orderNote->getAdmin() === $this) {
  604.                 $orderNote->setAdmin(null);
  605.             }
  606.         }
  608.         return $this;
  609.     }
  611.     /**
  612.      * @return Collection<int, ImplementerOrderHistory>
  613.      */
  614.     public
  615.         function getImplementerOrderHistories(
  616.     ): Collection {
  617.         return $this->implementerOrderHistories;
  618.     }
  620.     public
  621.         function addImplementerOrderHistory(
  622.         ImplementerOrderHistory $implementerOrderHistory
  623.     ): static {
  624.         if (!$this->implementerOrderHistories->contains($implementerOrderHistory)) {
  625.             $this->implementerOrderHistories->add($implementerOrderHistory);
  626.             $implementerOrderHistory->setAdmin($this);
  627.         }
  629.         return $this;
  630.     }
  632.     public function removeImplementerOrderHistory(ImplementerOrderHistory $implementerOrderHistory): static
  633.     {
  634.         if ($this->implementerOrderHistories->removeElement($implementerOrderHistory)) {
  635.             // set the owning side to null (unless already changed)
  636.             if ($implementerOrderHistory->getAdmin() === $this) {
  637.                 $implementerOrderHistory->setAdmin(null);
  638.             }
  639.         }
  641.         return $this;
  642.     }
  644.     /**
  645.      * @return Collection<int, OrderNote>
  646.      */
  647.     public function getOrderEditedNotes(): Collection
  648.     {
  649.         return $this->orderEditedNotes;
  650.     }
  652.     public function addOrderEditedNote(OrderNote $orderEditedNote): static
  653.     {
  654.         if (!$this->orderEditedNotes->contains($orderEditedNote)) {
  655.             $this->orderEditedNotes->add($orderEditedNote);
  656.             $orderEditedNote->setLastEditedBy($this);
  657.         }
  659.         return $this;
  660.     }
  662.     public function removeOrderEditedNote(OrderNote $orderEditedNote): static
  663.     {
  664.         if ($this->orderEditedNotes->removeElement($orderEditedNote)) {
  665.             // set the owning side to null (unless already changed)
  666.             if ($orderEditedNote->getLastEditedBy() === $this) {
  667.                 $orderEditedNote->setLastEditedBy(null);
  668.             }
  669.         }
  671.         return $this;
  672.     }
  674.     /**
  675.      * @return Collection<int, Order>
  676.      */
  677.     public function getOrders(): Collection
  678.     {
  679.         return $this->orders;
  680.     }
  682.     public function addOrder(Order $order): static
  683.     {
  684.         if (!$this->orders->contains($order)) {
  685.             $this->orders->add($order);
  686.             $order->setAdmin($this);
  687.         }
  689.         return $this;
  690.     }
  692.     public function removeOrder(Order $order): static
  693.     {
  694.         if ($this->orders->removeElement($order)) {
  695.             // set the owning side to null (unless already changed)
  696.             if ($order->getAdmin() === $this) {
  697.                 $order->setAdmin(null);
  698.             }
  699.         }
  701.         return $this;
  702.     }
  704.     /**
  705.      * @return Collection<int, CommercialOffer>
  706.      */
  707.     public function getCommercialOffers(): Collection
  708.     {
  709.         return $this->commercialOffers;
  710.     }
  712.     public function addCommercialOffer(CommercialOffer $commercialOffer): static
  713.     {
  714.         if (!$this->commercialOffers->contains($commercialOffer)) {
  715.             $this->commercialOffers->add($commercialOffer);
  716.             $commercialOffer->setAddedBy($this);
  717.         }
  719.         return $this;
  720.     }
  722.     public function removeCommercialOffer(CommercialOffer $commercialOffer): static
  723.     {
  724.         if ($this->commercialOffers->removeElement($commercialOffer)) {
  725.             // set the owning side to null (unless already changed)
  726.             if ($commercialOffer->getAddedBy() === $this) {
  727.                 $commercialOffer->setAddedBy(null);
  728.             }
  729.         }
  731.         return $this;
  732.     }
  734.     /**
  735.      * @return Collection<int, WorkHistory>
  736.      */
  737.     public function getWorkHistories(): Collection
  738.     {
  739.         return $this->workHistories;
  740.     }
  742.     public function addWorkHistory(WorkHistory $workHistory): static
  743.     {
  744.         if (!$this->workHistories->contains($workHistory)) {
  745.             $this->workHistories->add($workHistory);
  746.             $workHistory->setAdmin($this);
  747.         }
  749.         return $this;
  750.     }
  752.     public function removeWorkHistory(WorkHistory $workHistory): static
  753.     {
  754.         if ($this->workHistories->removeElement($workHistory)) {
  755.             // set the owning side to null (unless already changed)
  756.             if ($workHistory->getAdmin() === $this) {
  757.                 $workHistory->setAdmin(null);
  758.             }
  759.         }
  761.         return $this;
  762.     }
  764.     /**
  765.      * @return Collection<int, CommercialOfferIndividual>
  766.      */
  767.     public function getCommercialOfferIndividuals(): Collection
  768.     {
  769.         return $this->commercialOfferIndividuals;
  770.     }
  772.     public function addCommercialOfferIndividual(CommercialOfferIndividual $commercialOfferIndividual): static
  773.     {
  774.         if (!$this->commercialOfferIndividuals->contains($commercialOfferIndividual)) {
  775.             $this->commercialOfferIndividuals->add($commercialOfferIndividual);
  776.             $commercialOfferIndividual->setCreatedByAdmin($this);
  777.         }
  779.         return $this;
  780.     }
  782.     public function removeCommercialOfferIndividual(CommercialOfferIndividual $commercialOfferIndividual): static
  783.     {
  784.         if ($this->commercialOfferIndividuals->removeElement($commercialOfferIndividual)) {
  785.             // set the owning side to null (unless already changed)
  786.             if ($commercialOfferIndividual->getCreatedByAdmin() === $this) {
  787.                 $commercialOfferIndividual->setCreatedByAdmin(null);
  788.             }
  789.         }
  791.         return $this;
  792.     }
  794.     /**
  795.      * @return Collection<int, AudioAsset>
  796.      */
  797.     public function getAudioAssets(): Collection
  798.     {
  799.         return $this->audioAssets;
  800.     }
  802.     public function addAudioAsset(AudioAsset $audioAsset): static
  803.     {
  804.         if (!$this->audioAssets->contains($audioAsset)) {
  805.             $this->audioAssets->add($audioAsset);
  806.             $audioAsset->setCreatedBy($this);
  807.         }
  809.         return $this;
  810.     }
  812.     public function removeAudioAsset(AudioAsset $audioAsset): static
  813.     {
  814.         if ($this->audioAssets->removeElement($audioAsset)) {
  815.             // set the owning side to null (unless already changed)
  816.             if ($audioAsset->getCreatedBy() === $this) {
  817.                 $audioAsset->setCreatedBy(null);
  818.             }
  819.         }
  821.         return $this;
  822.     }
  824.     /**
  825.      * @return Collection<int, CommercialOfferSendings>
  826.      */
  827.     public function getCommercialOfferSendings(): Collection
  828.     {
  829.         return $this->commercialOfferSendings;
  830.     }
  832.     public function addCommercialOfferSending(CommercialOfferSendings $commercialOfferSending): static
  833.     {
  834.         if (!$this->commercialOfferSendings->contains($commercialOfferSending)) {
  835.             $this->commercialOfferSendings->add($commercialOfferSending);
  836.             $commercialOfferSending->setAddedByAdmin($this);
  837.         }
  839.         return $this;
  840.     }
  842.     public function removeCommercialOfferSending(CommercialOfferSendings $commercialOfferSending): static
  843.     {
  844.         if ($this->commercialOfferSendings->removeElement($commercialOfferSending)) {
  845.             // set the owning side to null (unless already changed)
  846.             if ($commercialOfferSending->getAddedByAdmin() === $this) {
  847.                 $commercialOfferSending->setAddedByAdmin(null);
  848.             }
  849.         }
  851.         return $this;
  852.     }
  854.     /**
  855.      * @return Collection<int, CommercialOfferSendings>
  856.      */
  857.     public function getCommercialOfferSendingsAccepts(): Collection
  858.     {
  859.         return $this->commercialOfferSendingsAccepts;
  860.     }
  861.     /**
  862.      * @return Collection<int, CommercialOfferIndividual>
  863.      */
  864.     public function getCommercialOfferIndividualsAccepted(): Collection
  865.     {
  866.         return $this->commercialOfferIndividualsAccepted;
  867.     }
  869.     /**
  870.      * @return Collection<int, Reservations>
  871.      */
  872.     public function getReservations(): Collection
  873.     {
  874.         return $this->reservations;
  875.     }
  877.     public function addReservation(Reservations $reservation): static
  878.     {
  879.         if (!$this->reservations->contains($reservation)) {
  880.             $this->reservations->add($reservation);
  881.             $reservation->setAddedByAdmin($this);
  882.         }
  884.         return $this;
  885.     }
  887.     public function removeReservation(Reservations $reservation): static
  888.     {
  889.         if ($this->reservations->removeElement($reservation)) {
  890.             // set the owning side to null (unless already changed)
  891.             if ($reservation->getAddedByAdmin() === $this) {
  892.                 $reservation->setAddedByAdmin(null);
  893.             }
  894.         }
  896.         return $this;
  897.     }
  899.     /**
  900.      * @return Collection<int, Reservations>
  901.      */
  902.     public function getReservationsEdit(): Collection
  903.     {
  904.         return $this->reservationsEdit;
  905.     }
  907.     public function addReservationsEdit(Reservations $reservationsEdit): static
  908.     {
  909.         if (!$this->reservationsEdit->contains($reservationsEdit)) {
  910.             $this->reservationsEdit->add($reservationsEdit);
  911.             $reservationsEdit->setLastEditedBy($this);
  912.         }
  914.         return $this;
  915.     }
  917.     public function removeReservationsEdit(Reservations $reservationsEdit): static
  918.     {
  919.         if ($this->reservationsEdit->removeElement($reservationsEdit)) {
  920.             // set the owning side to null (unless already changed)
  921.             if ($reservationsEdit->getLastEditedBy() === $this) {
  922.                 $reservationsEdit->setLastEditedBy(null);
  923.             }
  924.         }
  926.         return $this;
  927.     }
  929.     /**
  930.      * @return Collection<int, DirectMessage>
  931.      */
  932.     public function getDirectMessagesSent(): Collection
  933.     {
  934.         return $this->directMessagesSent;
  935.     }
  937.     public function addDirectMessagesSent(DirectMessage $directMessagesSent): static
  938.     {
  939.         if (!$this->directMessagesSent->contains($directMessagesSent)) {
  940.             $this->directMessagesSent->add($directMessagesSent);
  941.             $directMessagesSent->setSenderAdmin($this);
  942.         }
  944.         return $this;
  945.     }
  947.     public function removeDirectMessagesSent(DirectMessage $directMessagesSent): static
  948.     {
  949.         if ($this->directMessagesSent->removeElement($directMessagesSent)) {
  950.             // set the owning side to null (unless already changed)
  951.             if ($directMessagesSent->getSenderAdmin() === $this) {
  952.                 $directMessagesSent->setSenderAdmin(null);
  953.             }
  954.         }
  956.         return $this;
  957.     }
  959.     /**
  960.      * @return Collection<int, DirectMessage>
  961.      */
  962.     public function getDirectMessagesReceived(): Collection
  963.     {
  964.         return $this->directMessagesReceived;
  965.     }
  967.     public function addDirectMessagesReceived(DirectMessage $directMessagesReceived): static
  968.     {
  969.         if (!$this->directMessagesReceived->contains($directMessagesReceived)) {
  970.             $this->directMessagesReceived->add($directMessagesReceived);
  971.             $directMessagesReceived->setReceiverAdmin($this);
  972.         }
  974.         return $this;
  975.     }
  977.     public function removeDirectMessagesReceived(DirectMessage $directMessagesReceived): static
  978.     {
  979.         if ($this->directMessagesReceived->removeElement($directMessagesReceived)) {
  980.             // set the owning side to null (unless already changed)
  981.             if ($directMessagesReceived->getReceiverAdmin() === $this) {
  982.                 $directMessagesReceived->setReceiverAdmin(null);
  983.             }
  984.         }
  986.         return $this;
  987.     }
  989.     public function isRemoteAccess(): ?bool
  990.     {
  991.         return $this->remoteAccess;
  992.     }
  994.     public function setRemoteAccess(bool $remoteAccess): static
  995.     {
  996.         $this->remoteAccess = $remoteAccess;
  998.         return $this;
  999.     }
  1001.     /**
  1002.      * @return Collection<int, AdminNotificationSettings>
  1003.      */
  1004.     public function getAdminNotificationSettings(): Collection
  1005.     {
  1006.         return $this->adminNotificationSettings;
  1007.     }
  1009.     public function addAdminNotificationSetting(AdminNotificationSettings $adminNotificationSetting): static
  1010.     {
  1011.         if (!$this->adminNotificationSettings->contains($adminNotificationSetting)) {
  1012.             $this->adminNotificationSettings->add($adminNotificationSetting);
  1013.             $adminNotificationSetting->setAdmin($this);
  1014.         }
  1016.         return $this;
  1017.     }
  1019.     public function removeAdminNotificationSetting(AdminNotificationSettings $adminNotificationSetting): static
  1020.     {
  1021.         if ($this->adminNotificationSettings->removeElement($adminNotificationSetting)) {
  1022.             // set the owning side to null (unless already changed)
  1023.             if ($adminNotificationSetting->getAdmin() === $this) {
  1024.                 $adminNotificationSetting->setAdmin(null);
  1025.             }
  1026.         }
  1028.         return $this;
  1029.     }
  1031.     /**
  1032.      * @return Collection<int, DebtNote>
  1033.      */
  1034.     public function getDebtNotes(): Collection
  1035.     {
  1036.         return $this->debtNotes;
  1037.     }
  1039.     public function addDebtNote(DebtNote $debtNote): static
  1040.     {
  1041.         if (!$this->debtNotes->contains($debtNote)) {
  1042.             $this->debtNotes->add($debtNote);
  1043.             $debtNote->setAdmin($this);
  1044.         }
  1046.         return $this;
  1047.     }
  1049.     public function removeDebtNote(DebtNote $debtNote): static
  1050.     {
  1051.         if ($this->debtNotes->removeElement($debtNote)) {
  1052.             // set the owning side to null (unless already changed)
  1053.             if ($debtNote->getAdmin() === $this) {
  1054.                 $debtNote->setAdmin(null);
  1055.             }
  1056.         }
  1058.         return $this;
  1059.     }
  1061.     /**
  1062.      * @return Collection<int, CustomerHistory>
  1063.      */
  1064.     public function getCustomerHistories(): Collection
  1065.     {
  1066.         return $this->customerHistories;
  1067.     }
  1069.     public function addCustomerHistory(CustomerHistory $customerHistory): static
  1070.     {
  1071.         if (!$this->customerHistories->contains($customerHistory)) {
  1072.             $this->customerHistories->add($customerHistory);
  1073.             $customerHistory->setAdmin($this);
  1074.         }
  1076.         return $this;
  1077.     }
  1079.     public function removeCustomerHistory(CustomerHistory $customerHistory): static
  1080.     {
  1081.         if ($this->customerHistories->removeElement($customerHistory)) {
  1082.             // set the owning side to null (unless already changed)
  1083.             if ($customerHistory->getAdmin() === $this) {
  1084.                 $customerHistory->setAdmin(null);
  1085.             }
  1086.         }
  1088.         return $this;
  1089.     }
  1091.     public function getPhoto(): ?string
  1092.     {
  1093.         return $this->photo;
  1094.     }
  1096.     public function setPhoto(?string $photo): static
  1097.     {
  1098.         $this->photo = $photo;
  1100.         return $this;
  1101.     }
  1103.     public function isSendMail(): bool
  1104.     {
  1105.         return $this->sendMail;
  1106.     }
  1108.     public function setSendMail(bool $sendMail): static
  1109.     {
  1110.         $this->sendMail = $sendMail;
  1112.         return $this;
  1113.     }
  1115.     /**
  1116.      * @return Collection<int, Product>
  1117.      */
  1118.     public function getProducts(): Collection
  1119.     {
  1120.         return $this->products;
  1121.     }
  1123.     public function addProduct(Product $product): static
  1124.     {
  1125.         if (!$this->products->contains($product)) {
  1126.             $this->products->add($product);
  1127.             $product->addAdminToInfo($this);
  1128.         }
  1130.         return $this;
  1131.     }
  1133.     public function removeProduct(Product $product): static
  1134.     {
  1135.         if ($this->products->removeElement($product)) {
  1136.             $product->removeAdminToInfo($this);
  1137.         }
  1139.         return $this;
  1140.     }
  1142.     /**
  1143.      * @return Collection<int, SmsHistory>
  1144.      */
  1145.     public function getSmsHistories(): Collection
  1146.     {
  1147.         return $this->smsHistories;
  1148.     }
  1150.     public function addSmsHistory(SmsHistory $smsHistory): static
  1151.     {
  1152.         if (!$this->smsHistories->contains($smsHistory)) {
  1153.             $this->smsHistories->add($smsHistory);
  1154.             $smsHistory->setSendByAdmin($this);
  1155.         }
  1157.         return $this;
  1158.     }
  1160.     public function removeSmsHistory(SmsHistory $smsHistory): static
  1161.     {
  1162.         if ($this->smsHistories->removeElement($smsHistory)) {
  1163.             // set the owning side to null (unless already changed)
  1164.             if ($smsHistory->getSendByAdmin() === $this) {
  1165.                 $smsHistory->setSendByAdmin(null);
  1166.             }
  1167.         }
  1169.         return $this;
  1170.     }
  1172.     /**
  1173.      * @return Collection<int, NotificationToSendSetting>
  1174.      */
  1175.     public function getNotificationToSendSettings(): Collection
  1176.     {
  1177.         return $this->notificationToSendSettings;
  1178.     }
  1180.     public function addNotificationToSendSetting(NotificationToSendSetting $notificationToSendSetting): static
  1181.     {
  1182.         if (!$this->notificationToSendSettings->contains($notificationToSendSetting)) {
  1183.             $this->notificationToSendSettings->add($notificationToSendSetting);
  1184.             $notificationToSendSetting->addAdmin($this);
  1185.         }
  1187.         return $this;
  1188.     }
  1190.     public function removeNotificationToSendSetting(NotificationToSendSetting $notificationToSendSetting): static
  1191.     {
  1192.         if ($this->notificationToSendSettings->removeElement($notificationToSendSetting)) {
  1193.             $notificationToSendSetting->removeAdmin($this);
  1194.         }
  1196.         return $this;
  1197.     }
  1199.     public function getMailbox(): ?Mailbox
  1200.     {
  1201.         return $this->mailbox;
  1202.     }
  1204.     public function setMailbox(?Mailbox $mailbox): static
  1205.     {
  1206.         // unset the owning side of the relation if necessary
  1207.         if ($mailbox === null && $this->mailbox !== null) {
  1208.             $this->mailbox->setAdmin(null);
  1209.         }
  1211.         // set the owning side of the relation if necessary
  1212.         if ($mailbox !== null && $mailbox->getAdmin() !== $this) {
  1213.             $mailbox->setAdmin($this);
  1214.         }
  1216.         $this->mailbox = $mailbox;
  1217.         return $this;
  1218.     }
  1220.     /**
  1221.      * @return Collection<int, LeaveRequest>
  1222.      */
  1223.     public function getAcceptedLeaveRequests(): Collection
  1224.     {
  1225.         return $this->acceptedLeaveRequests;
  1226.     }
  1228.     public function addAcceptedLeaveRequest(LeaveRequest $acceptedLeaveRequest): static
  1229.     {
  1230.         if (!$this->acceptedLeaveRequests->contains($acceptedLeaveRequest)) {
  1231.             $this->acceptedLeaveRequests->add($acceptedLeaveRequest);
  1232.             $acceptedLeaveRequest->setAcceptedBy($this);
  1233.         }
  1235.         return $this;
  1236.     }
  1238.     public function removeAcceptedLeaveRequest(LeaveRequest $acceptedLeaveRequest): static
  1239.     {
  1240.         if ($this->acceptedLeaveRequests->removeElement($acceptedLeaveRequest)) {
  1241.             // set the owning side to null (unless already changed)
  1242.             if ($acceptedLeaveRequest->getAcceptedBy() === $this) {
  1243.                 $acceptedLeaveRequest->setAcceptedBy(null);
  1244.             }
  1245.         }
  1247.         return $this;
  1248.     }
  1250.     /**
  1251.      * @return Collection<int, LeaveRequest>
  1252.      */
  1253.     public function getRejectedLeaveRequests(): Collection
  1254.     {
  1255.         return $this->rejectedLeaveRequests;
  1256.     }
  1258.     public function addRejectedLeaveRequest(LeaveRequest $rejectedLeaveRequest): static
  1259.     {
  1260.         if (!$this->rejectedLeaveRequests->contains($rejectedLeaveRequest)) {
  1261.             $this->rejectedLeaveRequests->add($rejectedLeaveRequest);
  1262.             $rejectedLeaveRequest->setRejectedBy($this);
  1263.         }
  1265.         return $this;
  1266.     }
  1268.     public function removeRejectedLeaveRequest(LeaveRequest $rejectedLeaveRequest): static
  1269.     {
  1270.         if ($this->rejectedLeaveRequests->removeElement($rejectedLeaveRequest)) {
  1271.             // set the owning side to null (unless already changed)
  1272.             if ($rejectedLeaveRequest->getRejectedBy() === $this) {
  1273.                 $rejectedLeaveRequest->setRejectedBy(null);
  1274.             }
  1275.         }
  1277.         return $this;
  1278.     }
  1280.     /**
  1281.      * @return Collection<int, Task>
  1282.      */
  1283.     public function getAcceptedTasks(): Collection
  1284.     {
  1285.         return $this->acceptedTasks;
  1286.     }
  1288.     public function addAcceptedTask(Task $acceptedTask): static
  1289.     {
  1290.         if (!$this->acceptedTasks->contains($acceptedTask)) {
  1291.             $this->acceptedTasks->add($acceptedTask);
  1292.             $acceptedTask->setAcceptedBy($this);
  1293.         }
  1295.         return $this;
  1296.     }
  1298.     public function removeAcceptedTask(Task $acceptedTask): static
  1299.     {
  1300.         if ($this->acceptedTasks->removeElement($acceptedTask)) {
  1301.             // set the owning side to null (unless already changed)
  1302.             if ($acceptedTask->getAcceptedBy() === $this) {
  1303.                 $acceptedTask->setAcceptedBy(null);
  1304.             }
  1305.         }
  1307.         return $this;
  1308.     }
  1310.     public function getPosition(): ?Position
  1311.     {
  1312.         return $this->position;
  1313.     }
  1315.     public function setPosition(?Position $position): static
  1316.     {
  1317.         $this->position = $position;
  1319.         return $this;
  1320.     }
  1322.     /**
  1323.      * @return Collection<int, Agreement>
  1324.      */
  1325.     public function getAgreementsToSendAfterSigned(): Collection
  1326.     {
  1327.         return $this->agreementsToSendAfterSigned;
  1328.     }
  1330.     public function addAgreementsToSendAfterSigned(Agreement $agreementsToSendAfterSigned): static
  1331.     {
  1332.         if (!$this->agreementsToSendAfterSigned->contains($agreementsToSendAfterSigned)) {
  1333.             $this->agreementsToSendAfterSigned->add($agreementsToSendAfterSigned);
  1334.             $agreementsToSendAfterSigned->addAgreementToSendAfterSigned($this);
  1335.         }
  1337.         return $this;
  1338.     }
  1340.     public function removeAgreementsToSendAfterSigned(Agreement $agreementsToSendAfterSigned): static
  1341.     {
  1342.         if ($this->agreementsToSendAfterSigned->removeElement($agreementsToSendAfterSigned)) {
  1343.             $agreementsToSendAfterSigned->removeAgreementToSendAfterSigned($this);
  1344.         }
  1346.         return $this;
  1347.     }
  1348.     /**
  1349.      * @return Collection<int, WorkTime>
  1350.      */
  1351.     public function getWorkTimes(): Collection
  1352.     {
  1353.         return $this->workTimes;
  1354.     }
  1356.     public function addWorkTime(WorkTime $workTime): static
  1357.     {
  1358.         if (!$this->workTimes->contains($workTime)) {
  1359.             $this->workTimes->add($workTime);
  1360.             $workTime->setAdminInstance($this);
  1361.         }
  1363.         return $this;
  1364.     }
  1366.     public function removeWorkTime(WorkTime $workTime): static
  1367.     {
  1368.         if ($this->workTimes->removeElement($workTime)) {
  1369.             // set the owning side to null (unless already changed)
  1370.             if ($workTime->getAdmin() === $this) {
  1371.                 $workTime->setAdmin(null);
  1372.             }
  1373.         }
  1375.         return $this;
  1376.     }
  1378.     public function getNominalWorkTime(): ?NominalWorkTime
  1379.     {
  1380.         return $this->nominalWorkTime;
  1381.     }
  1383.     public function setNominalWorkTime(?NominalWorkTime $nominalWorkTime): static
  1384.     {
  1385.         $this->nominalWorkTime = $nominalWorkTime;
  1387.         return $this;
  1388.     }
  1390.     /**
  1391.      * @return Collection<int, LeaveRequest>
  1392.      */
  1393.     public function getLeaveRequests(): Collection
  1394.     {
  1395.         return $this->leaveRequests;
  1396.     }
  1398.     public function getLeaveRequestsFrom2026(): Collection
  1399.     {
  1400.         return $this->leaveRequests->filter(function (LeaveRequest $lr) {
  1401.             return $lr->getStartTime() >= new DateTimeImmutable('2026-01-01 00:00:00');
  1402.         });
  1403.     }
  1405.     public function addLeaveRequest(LeaveRequest $leaveRequest): static
  1406.     {
  1407.         if (!$this->leaveRequests->contains($leaveRequest)) {
  1408.             $this->leaveRequests->add($leaveRequest);
  1409.             $leaveRequest->setAdmin($this);
  1410.         }
  1412.         return $this;
  1413.     }
  1415.     public function removeLeaveRequest(LeaveRequest $leaveRequest): static
  1416.     {
  1417.         if ($this->leaveRequests->removeElement($leaveRequest)) {
  1418.             // set the owning side to null (unless already changed)
  1419.             if ($leaveRequest->getAdmin() === $this) {
  1420.                 $leaveRequest->setAdmin(null);
  1421.             }
  1422.         }
  1424.         return $this;
  1425.     }
  1427.     /**
  1428.      * @return Collection<int, AccountingOfficeSendingNote>
  1429.      */
  1430.     public function getAccountingOfficeSendingNotes(): Collection
  1431.     {
  1432.         return $this->accountingOfficeSendingNotes;
  1433.     }
  1435.     public function addAccountingOfficeSendingNote(AccountingOfficeSendingNote $accountingOfficeSendingNote): static
  1436.     {
  1437.         if (!$this->accountingOfficeSendingNotes->contains($accountingOfficeSendingNote)) {
  1438.             $this->accountingOfficeSendingNotes->add($accountingOfficeSendingNote);
  1439.             $accountingOfficeSendingNote->setAdmin($this);
  1440.         }
  1442.         return $this;
  1443.     }
  1445.     public function removeAccountingOfficeSendingNote(AccountingOfficeSendingNote $accountingOfficeSendingNote): static
  1446.     {
  1447.         if ($this->accountingOfficeSendingNotes->removeElement($accountingOfficeSendingNote)) {
  1448.             // set the owning side to null (unless already changed)
  1449.             if ($accountingOfficeSendingNote->getAdmin() === $this) {
  1450.                 $accountingOfficeSendingNote->setAdmin(null);
  1451.             }
  1452.         }
  1454.         return $this;
  1455.     }
  1457.     public function isToRcp(): bool
  1458.     {
  1459.         return $this->toRcp;
  1460.     }
  1462.     public function setToRcp(bool $toRcp): void
  1463.     {
  1464.         $this->toRcp = $toRcp;
  1465.     }
  1467.     /**
  1468.      * @return Collection<int, WorkTime>
  1469.      */
  1470.     public function getAcceptedWorkTimes(): Collection
  1471.     {
  1472.         return $this->acceptedWorkTimes;
  1473.     }
  1475.     public function addAcceptedWorkTime(WorkTime $acceptedWorkTime): static
  1476.     {
  1477.         if (!$this->acceptedWorkTimes->contains($acceptedWorkTime)) {
  1478.             $this->acceptedWorkTimes->add($acceptedWorkTime);
  1479.             $acceptedWorkTime->setAcceptedBy($this);
  1480.         }
  1482.         return $this;
  1483.     }
  1485.     public function removeAcceptedWorkTime(WorkTime $acceptedWorkTime): static
  1486.     {
  1487.         if ($this->acceptedWorkTimes->removeElement($acceptedWorkTime)) {
  1488.             // set the owning side to null (unless already changed)
  1489.             if ($acceptedWorkTime->getAcceptedBy() === $this) {
  1490.                 $acceptedWorkTime->setAcceptedBy(null);
  1491.             }
  1492.         }
  1494.         return $this;
  1495.     }
  1497.     /**
  1498.      * @return Collection<int, Department>
  1499.      */
  1500.     public function getDepartments(): Collection
  1501.     {
  1502.         return $this->departments;
  1503.     }
  1505.     public function addDepartment(Department $department): static
  1506.     {
  1507.         if (!$this->departments->contains($department)) {
  1508.             $this->departments->add($department);
  1509.             $department->addManagement($this);
  1510.         }
  1512.         return $this;
  1513.     }
  1515.     public function removeDepartment(Department $department): static
  1516.     {
  1517.         if ($this->departments->removeElement($department)) {
  1518.             $department->removeManagement($this);
  1519.         }
  1521.         return $this;
  1522.     }
  1524.     /** @return Collection<int, NumberBlocking> */
  1525.     public function getNumberBlockings(): Collection
  1526.     {
  1527.         return $this->numberBlockings;
  1528.     }
  1530.     public function addNumberBlocking(NumberBlocking $nb): self
  1531.     {
  1532.         if (!$this->numberBlockings->contains($nb)) {
  1533.             $this->numberBlockings->add($nb);
  1534.             $nb->setAddedBy($this);
  1535.         }
  1536.         return $this;
  1537.     }
  1539.     public function removeNumberBlocking(NumberBlocking $nb): self
  1540.     {
  1541.         if ($this->numberBlockings->removeElement($nb)) {
  1542.             if ($nb->getAddedBy() === $this) {
  1543.                 $nb->setAddedBy(null);
  1544.             }
  1545.         }
  1546.         return $this;
  1547.     }
  1549.     /** @return Collection<int, NumberBlocking> */
  1550.     public function getNumberBlockingsBlocked(): Collection
  1551.     {
  1552.         return $this->numberBlockingsBlocked;
  1553.     }
  1555.     public function addNumberBlockingBlocked(NumberBlocking $nb): self
  1556.     {
  1557.         if (!$this->numberBlockingsBlocked->contains($nb)) {
  1558.             $this->numberBlockingsBlocked->add($nb);
  1559.             $nb->setBlockedBy($this);
  1560.         }
  1561.         return $this;
  1562.     }
  1564.     public function removeNumberBlockingBlocked(NumberBlocking $nb): self
  1565.     {
  1566.         if ($this->numberBlockingsBlocked->removeElement($nb)) {
  1567.             if ($nb->getBlockedBy() === $this) {
  1568.                 $nb->setBlockedBy(null);
  1569.             }
  1570.         }
  1571.         return $this;
  1572.     }
  1574.     public function getAdminDepartment(): ?AdminDepartment
  1575.     {
  1576.         return $this->adminDepartment;
  1577.     }
  1579.     public function setAdminDepartment(?AdminDepartment $adminDepartment): static
  1580.     {
  1581.         $this->adminDepartment = $adminDepartment;
  1583.         return $this;
  1584.     }
  1586.     public function isAcceptedRegulations(): ?bool
  1587.     {
  1588.         return $this->acceptedRegulations;
  1589.     }
  1591.     public function setAcceptedRegulations(bool $acceptedRegulations): static
  1592.     {
  1593.         $this->acceptedRegulations = $acceptedRegulations;
  1595.         return $this;
  1596.     }
  1598.     public function getAcceptedRegulationsDate(): ?\DateTimeInterface
  1599.     {
  1600.         return $this->acceptedRegulationsDate;
  1601.     }
  1603.     public function setAcceptedRegulationsDate(?\DateTimeInterface $acceptedRegulationsDate): static
  1604.     {
  1605.         $this->acceptedRegulationsDate = $acceptedRegulationsDate;
  1607.         return $this;
  1608.     }
  1610.     public function isAcceptedZfss(): ?bool
  1611.     {
  1612.         return $this->acceptedZfss;
  1613.     }
  1615.     public function setAcceptedZfss(bool $acceptedZfss): static
  1616.     {
  1617.         $this->acceptedZfss = $acceptedZfss;
  1619.         return $this;
  1620.     }
  1622.     public function getAcceptedZfssDate(): ?\DateTimeInterface
  1623.     {
  1624.         return $this->acceptedZfssDate;
  1625.     }
  1627.     public function setAcceptedZfssDate(?\DateTimeInterface $acceptedZfssDate): static
  1628.     {
  1629.         $this->acceptedZfssDate = $acceptedZfssDate;
  1631.         return $this;
  1632.     }
  1634.     public function getAdminContractType(): ?EmploymentContractType
  1635.     {
  1636.         return $this->adminContractType;
  1637.     }
  1639.     public function setAdminContractType(?EmploymentContractType $adminContractType): static
  1640.     {
  1641.         $this->adminContractType = $adminContractType;
  1643.         return $this;
  1644.     }
  1646.     /**
  1647.      * @return Collection<int, LeaveRequestBalance>
  1648.      */
  1649.     public function getLeaveRequestBalances(): Collection
  1650.     {
  1651.         return $this->leaveRequestBalances;
  1652.     }
  1654.     public function addLeaveRequestBalance(LeaveRequestBalance $leaveRequestBalance): static
  1655.     {
  1656.         if (!$this->leaveRequestBalances->contains($leaveRequestBalance)) {
  1657.             $this->leaveRequestBalances->add($leaveRequestBalance);
  1658.             $leaveRequestBalance->setAdmin($this);
  1659.         }
  1661.         return $this;
  1662.     }
  1664.     public function removeLeaveRequestBalance(LeaveRequestBalance $leaveRequestBalance): static
  1665.     {
  1666.         if ($this->leaveRequestBalances->removeElement($leaveRequestBalance)) {
  1667.             // set the owning side to null (unless already changed)
  1668.             if ($leaveRequestBalance->getAdmin() === $this) {
  1669.                 $leaveRequestBalance->setAdmin(null);
  1670.             }
  1671.         }
  1673.         return $this;
  1674.     }
  1676.     public function getMailFooter(): ?string
  1677.     {
  1678.         return $this->mailFooter;
  1679.     }
  1681.     public function setMailFooter(?string $mailFooter): static
  1682.     {
  1683.         $this->mailFooter = $mailFooter;
  1685.         return $this;
  1686.     }
  1688.     public function getTodayWorkTimeFromLoadedCollection(): ?WorkTime
  1689.     {
  1690.         $today = (new DateTimeImmutable('today'))->format('Y-m-d');
  1692.         foreach ($this->getWorkTimes() as $workTime) {
  1693.             if ($workTime->getWorkDate()?->format('Y-m-d') === $today) {
  1694.                 return $workTime;
  1695.             }
  1696.         }
  1698.         return null;
  1699.     }
  1701.     public function isDisability(): bool
  1702.     {
  1703.         return $this->disability;
  1704.     }
  1706.     public function setDisability(bool $disability): void
  1707.     {
  1708.         $this->disability = $disability;
  1709.     }
  1710. }