1. <?php
3. namespace App\Entity;
5. use App\Enum\Currency;
6. use App\Enum\UnitType;
7. use App\Enum\EmployeeStatus;
8. use App\Enum\GroupName;
9. use App\Enum\RegionEnum;
10. use App\Repository\UserRepository;
11. use Doctrine\Common\Collections\ArrayCollection;
12. use Doctrine\Common\Collections\Collection;
13. use Doctrine\DBAL\Types\Types;
14. use Doctrine\ORM\Mapping as ORM;
15. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
16. use DH\Auditor\Provider\Doctrine\Auditing\Annotation\Auditable;
17. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
18. use Symfony\Component\Security\Core\User\UserInterface;
19. use Gedmo\Timestampable\Traits\TimestampableEntity;
22. #[ORM\Entity(repositoryClass: UserRepository::class)]
23. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
24. class User implements UserInterface, PasswordAuthenticatedUserInterface
25. {
26.     use TimestampableEntity;
27.     public const ROLE_SUPER_ADMIN = 'ROLE_SUPER_ADMIN';
28.     public const ROLE_ADMIN = 'ROLE_ADMIN';
29.     public const ROLE_USER = 'ROLE_USER';
30.     public const ROLE_INDIVIDUAL_PAYEE = 'ROLE_INDIVIDUAL_PAYEE';
31.     public const ROLE_MANAGER = 'ROLE_MANAGER';
32.     public const ROLE_EXECUTIVE = 'ROLE_EXECUTIVE';
33.     public const ROLE_DEFAULT = 'ROLE_USER';
34.     #[ORM\Id]
35.     #[ORM\GeneratedValue]
36.     #[ORM\Column]
37.     private ?int $id = null;
39.     #[ORM\Column(length: 320, unique: true)]
40.     private ?string $email = null;
42.     #[ORM\Column]
43.     private array $roles = [];
45.     /**
46.      * @var string The hashed password
47.      */
48.     #[ORM\Column]
49.     private ?string $password = null;
50.     public $plainPassword;
51.     #[ORM\Column]
52.     private bool $incentAccess = true;
56.     #[ORM\Column(length: 255, nullable: true)]
57.     private ?GroupName $groupName = null;
60.     #[ORM\ManyToOne(targetEntity: self::class, fetch: "EAGER")]
61.     private ?self $manager = null;
63.     #[ORM\Column(nullable: true)]
64.     private ?bool $creditEligible = true;
66.     #[ORM\Column(nullable: true)]
67.     private ?bool $commissionEligible = true;
69.     #[ORM\Column(length: 255, nullable: true)]
70.     private ?string $employeeID = null;
72.     #[ORM\ManyToOne(fetch: "EAGER")]
73.     private ?Plan $plan = null;
75.     #[ORM\Column(length: 255, nullable: true)]
76.     private ?EmployeeStatus $employeeStatus = EmployeeStatus::ACTIVE;
78.     #[ORM\Column(nullable: true)]
79.     private ?int $guaranteePeriod = 0;
81.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
82.     private ?\DateTimeInterface $guaranteeStartDate = null;
85.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserPaymentPeriod::class, orphanRemoval: true)]
86.     private Collection $userPaymentPeriods;
88.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: AggregatedTrueUp::class)]
89.     private Collection $aggregatedTrueUps;
91.     #[ORM\Column(length: 255, nullable: true)]
92.     private ?string $firstName = null;
94.     #[ORM\Column(length: 255, nullable: true)]
95.     private ?string $lastName = null;
97.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Position::class, fetch: 'EAGER')]
98.     private Collection $positions;
100.     #[ORM\Column(length: 255, nullable: true)]
101.     private ?string $managerName = null;
103.     #[ORM\Column(length: 500, nullable: true)]
104.     private ?string $titleRole = null;
106.     #[ORM\Column(nullable: true)]
107.     private ?float $guaranteeAmount = null;
109.     #[ORM\Column(length: 255, nullable: true)]
110.     private ?UnitType $guaranteeAmountUnitType = null;
112.     #[ORM\Column(length: 255, nullable: true)]
113.     private ?UnitType $guaranteePeriodUnitType = null;
115.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Commission::class)]
116.     private Collection $commissions;
118.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Credit::class)]
119.     private Collection $credits;
121.     #[ORM\Column(length: 255, nullable: true)]
122.     private ?string $middleName = null;
124.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
125.     private ?\DateTimeInterface $effectiveStartDate = null;
127.     #[ORM\Column(type: Types::TEXT, nullable: true)]
128.     private ?string $description = null;
130.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
131.     private ?\DateTimeInterface $hireDate = null;
133.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
134.     private ?\DateTimeInterface $terminationDate = null;
136.     #[ORM\Column]
137.     private ?float $personalTarget = 0;
139.     #[ORM\Column]
140.     private ?float $proratedPersonalTarget = 0;
142.     #[ORM\Column(length: 255)]
143.     private ?Currency $personalCurrency = Currency::USD;
145.     #[ORM\Column]
146.     private ?float $proratedSalary = 0;
148.     #[ORM\Column(length: 255)]
149.     private ?Currency $paymentCurrency = Currency::USD;
151.     #[ORM\Column]
152.     private ?float $salary = 0;
154.     #[ORM\Column(length: 255)]
155.     private ?Currency $salaryCurrency = Currency::USD;
159.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ManualPayment::class)]
160.     private Collection $manualPayments;
162.     #[ORM\ManyToOne(inversedBy: 'users', fetch: 'EAGER')]
163.     private ?Title $title = null;
165.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: OrderAssignment::class)]
166.     private Collection $orderAssignments;
168.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: EmployeeRepCode::class)]
169.     private Collection $employeeRepCodes;
171.     #[ORM\OneToMany(mappedBy: 'fromUser', targetEntity: NamedRelationshipPosition::class)]
172.     private Collection $fromNamedRelationshipPositions;
174.     #[ORM\OneToMany(mappedBy: 'toUser', targetEntity: NamedRelationshipPosition::class)]
175.     private Collection $toNamedRelationshipPositions;
177.     #[ORM\OneToMany(mappedBy: 'assignedUser', targetEntity: LookUpTable::class)]
178.     private Collection $lookUpTables;
180.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: RateTableAssignment::class)]
181.     private Collection $rateTableAssignments;
183.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: RuleCondition::class)]
184.     private Collection $ruleConditions;
186.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Hierarchy::class, cascade: ['persist', 'remove'])]
187.     private Collection $hierarchies;
189.     #[ORM\OneToMany(mappedBy: 'parentUser', targetEntity: Hierarchy::class)]
190.     #[ORM\OrderBy(['effectiveStartDate' => 'ASC'])]
191.     private Collection $parentHierarchies;
193.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
194.     private ?\DateTimeInterface $earningCommissionsStartDate = null;
196.     #[ORM\Column(nullable: true)]
197.     private ?int $earningCommissionsPeriod = null;
199.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
200.     private ?\DateTimeInterface $guaranteeAlertSentAt = null;
202.     #[ORM\ManyToOne(inversedBy: 'users', fetch: 'EAGER')]
203.     private ?Region $region = null;
205.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserLogin::class)]
206.     private Collection $userLogins;
208.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: AdMapping::class)]
209.     private Collection $adMappings;
211.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserRegion::class, cascade: ['persist', 'remove'])]
212.     private Collection $userRegions;
214.     #[ORM\OneToMany(mappedBy: 'toUser', targetEntity: CommissionShareRule::class)]
215.     private Collection $commissionShareRulesTo;
217.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
218.     private ?\DateTimeInterface $leaveOfAbsenceStartDate = null;
220.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
221.     private ?\DateTimeInterface $leaveOfAbsenceEndDate = null;
223.     public function __construct()
224.     {
225.         $this->userPaymentPeriods = new ArrayCollection();
226.         $this->aggregatedTrueUps = new ArrayCollection();
227.         $this->positions = new ArrayCollection();
228.         $this->commissions = new ArrayCollection();
229.         $this->credits = new ArrayCollection();
230.         $this->manualPayments = new ArrayCollection();
231.         $this->orderAssignments = new ArrayCollection();
232.         $this->employeeRepCodes = new ArrayCollection();
233.         $this->fromNamedRelationshipPositions = new ArrayCollection();
234.         $this->toNamedRelationshipPositions = new ArrayCollection();
235.         $this->lookUpTables = new ArrayCollection();
236.         $this->rateTableAssignments = new ArrayCollection();
237.         $this->ruleConditions = new ArrayCollection();
238.         $this->hierarchies = new ArrayCollection();
239.         $this->parentHierarchies = new ArrayCollection();
240.         $this->userLogins = new ArrayCollection();
241.         $this->adMappings = new ArrayCollection();
242.         $this->userRegions = new ArrayCollection();
243.         $this->hireDate = new \DateTime();
244.         $this->commissionShareRulesTo = new ArrayCollection();
245.     }
247.     public function getId(): ?int
248.     {
249.         return $this->id;
250.     }
252.     public function getEmail(): ?string
253.     {
254.         return $this->email;
255.     }
257.     public function setEmail(string $email): self
258.     {
259.         $this->email = $email;
261.         return $this;
262.     }
264.     /**
265.      * A visual identifier that represents this user.
266.      *
267.      * @see UserInterface
268.      */
269.     public function getUserIdentifier(): string
270.     {
271.         return (string) $this->email;
272.     }
274.     /**
275.      * @see UserInterface
276.      */
277.     public function getRoles(): array
278.     {
279.         $roles = $this->roles;
280.         // guarantee every user at least has ROLE_USER
281.         $roles[] = 'ROLE_USER';
283.         return array_unique($roles);
284.     }
286.     public function setRoles(array $roles): self
287.     {
288.         $this->roles = $roles;
290.         return $this;
291.     }
293.     public function addRole($role): self
294.     {
295.         $roles = $this->roles;
296.         $roles[] = $role;
297.         $this->setRoles(array_unique($roles));
298.         return $this;
299.     }
301.     public static function getRolesList($secure = false): array
302.     {
303.         $roles = [
304.             self::ROLE_USER => 'User',
305.             self::ROLE_SUPER_ADMIN => 'Super Admin',
306.             self::ROLE_ADMIN => 'Admin',
307.             self::ROLE_INDIVIDUAL_PAYEE => 'Individual Payee',
308.             self::ROLE_MANAGER => 'Manager',
309.             self::ROLE_EXECUTIVE => 'Executive',
310.         ];
313.         return $roles;
314.     }
316.     public function getRolesLabels(): string
317.     {
318.         $rolesList = self::getRolesList();
319.         $roles = [];
320.         foreach ($this->getRoles() as $role) {
321.             $label = 'label-info';
323.             if ($role === self::ROLE_SUPER_ADMIN){
324.                 $label = 'label-warning';
325.             }
326.             if ($role === self::ROLE_ADMIN){
327.                 $label = 'label-primary';
328.             }
329.             if ($role !== self::ROLE_DEFAULT) {
330.                 $roles[] = "<span class='label {$label}'>{$rolesList[$role]}</span>&nbsp;";
331.             }
332.         }
333.         return implode(' ', $roles);
334.     }
335.     /**
336.      * {@inheritdoc}
337.      */
338.     public function hasRole($role): bool
339.     {
340.         return in_array(strtoupper($role), $this->getRoles(), true);
341.     }
342.     /**
343.      * @see PasswordAuthenticatedUserInterface
344.      */
345.     public function getPassword(): ?string
346.     {
347.         return $this->password;
348.     }
350.     public function setPassword(string $password): self
351.     {
352.         $this->password = $password;
354.         return $this;
355.     }
357.     /**
358.      * @see UserInterface
359.      */
360.     public function eraseCredentials()
361.     {
362.         // If you store any temporary, sensitive data on the user, clear it here
363.         // $this->plainPassword = null;
364.     }
366.     public function isIncentAccess(): ?bool
367.     {
368.         return $this->incentAccess;
369.     }
371.     public function setIncentAccess(bool $incentAccess): self
372.     {
373.         $this->incentAccess = $incentAccess;
375.         return $this;
376.     }
378.     public function getFullName(): ?string
379.     {
380.         $string = sprintf('%s %s', $this->firstName, $this->lastName);
382.         if($this->getEmployeeID()){
383.             $string = sprintf('%s (%s)', $string, $this->getEmployeeID());
384.         }
385.         return $string;
386.     }
390.     public function getGroupName(): ?GroupName
391.     {
392.         return $this->groupName;
393.     }
395.     public function setGroupName(?GroupName $groupName): self
396.     {
397.         $this->groupName = $groupName;
399.         return $this;
400.     }
403.     public function getManager(): ?self
404.     {
405.         return $this->manager;
406.     }
408.     public function setManager(?self $manager): self
409.     {
410.         $this->manager = $manager;
412.         return $this;
413.     }
415.     public function isCreditEligible(): ?bool
416.     {
417.         return $this->creditEligible;
418.     }
420.     public function setCreditEligible(?bool $creditEligible): self
421.     {
422.         $this->creditEligible = $creditEligible;
424.         return $this;
425.     }
427.     public function isCommissionEligible(): ?bool
428.     {
429.         return $this->commissionEligible;
430.     }
432.     public function setCommissionEligible(?bool $commissionEligible): self
433.     {
434.         $this->commissionEligible = $commissionEligible;
436.         return $this;
437.     }
439.     public function getEmployeeID(): ?string
440.     {
441.         return $this->employeeID;
442.     }
444.     public function setEmployeeID(?string $employeeID): self
445.     {
446.         $this->employeeID = $employeeID;
448.         return $this;
449.     }
451.     public function getPlan(): ?Plan
452.     {
453.         return $this->plan;
454.     }
456.     public function setPlan(?Plan $plan): self
457.     {
458.         $this->plan = $plan;
460.         return $this;
461.     }
464.     public function getEmployeeStatus(): ?EmployeeStatus
465.     {
466.         return $this->employeeStatus;
467.     }
469.     public function setEmployeeStatus(?EmployeeStatus $employeeStatus): self
470.     {
471.         $this->employeeStatus = $employeeStatus;
473.         return $this;
474.     }
476.     public function __toString()
477.     {
478.         return $this->getFullName() ?: $this->email;
479.     }
481.     public function getGuaranteePeriod(): ?int
482.     {
483.         return $this->guaranteePeriod;
484.     }
486.     public function setGuaranteePeriod(?int $guaranteePeriod): self
487.     {
488.         $this->guaranteePeriod = $guaranteePeriod;
490.         // reset alert sent at
491.         $this->guaranteeAlertSentAt = null;
492.         return $this;
493.     }
495.     public function getGuaranteeStartDate(): ?\DateTimeInterface
496.     {
497.         return $this->guaranteeStartDate;
498.     }
500.     public function setGuaranteeStartDate(?\DateTimeInterface $guaranteeStartDate): self
501.     {
502.         $this->guaranteeStartDate = $guaranteeStartDate;
504.         // reset alert sent at
505.         $this->guaranteeAlertSentAt = null;
507.         return $this;
508.     }
511.     public function getGuaranteeEndDate(): ?\DateTimeInterface
512.     {
513.         $startDate = clone $this->getGuaranteeStartDate();
514.         if($startDate){
515.             $startDate->modify("+{$this->getGuaranteePeriod()} months")->sub(new \DateInterval('P1D'));
516.         }
518.         return $startDate;
519.     }
522.     /**
523.      * @return Collection<int, UserPaymentPeriod>
524.      */
525.     public function getFilteredUserPaymentPeriods(\DateTime $start, \DateTime $end): Collection
526.     {
527.         return $this->userPaymentPeriods;
528.     }
529.     /**
530.      * @return Collection<int, UserPaymentPeriod>
531.      */
532.     public function getUserPaymentPeriods(): Collection
533.     {
534.         return $this->userPaymentPeriods;
535.     }
537.     public function addUserPaymentPeriod(UserPaymentPeriod $userPaymentPeriod): self
538.     {
539.         if (!$this->userPaymentPeriods->contains($userPaymentPeriod)) {
540.             $this->userPaymentPeriods->add($userPaymentPeriod);
541.             $userPaymentPeriod->setUser($this);
542.         }
544.         return $this;
545.     }
547.     public function removeUserPaymentPeriod(UserPaymentPeriod $userPaymentPeriod): self
548.     {
549.         if ($this->userPaymentPeriods->removeElement($userPaymentPeriod)) {
550.             // set the owning side to null (unless already changed)
551.             if ($userPaymentPeriod->getUser() === $this) {
552.                 $userPaymentPeriod->setUser(null);
553.             }
554.         }
556.         return $this;
557.     }
559.     public function getUserPaymentPeriodsByDateRange(\DateTime $start, \DateTime $end)
560.     {
561.         $upp = [];
562.         foreach($this->userPaymentPeriods as $cand) {
563.             if ($cand->getPaymentPeriod()->getStart() >= $start && $cand->getPaymentPeriod()->getEnd() <= $end) {
564.                 $upp[] = $cand;
565.             }
566.         }
568.         return $upp;
570.     }
572.     /**
573.      * @return Collection<int, AggregatedTrueUp>
574.      */
575.     public function getAggregatedTrueUps(): Collection
576.     {
577.         return $this->aggregatedTrueUps;
578.     }
580.     public function addAggregatedTrueUp(AggregatedTrueUp $aggregatedTrueUp): self
581.     {
582.         if (!$this->aggregatedTrueUps->contains($aggregatedTrueUp)) {
583.             $this->aggregatedTrueUps->add($aggregatedTrueUp);
584.             $aggregatedTrueUp->setUser($this);
585.         }
587.         return $this;
588.     }
590.     public function removeAggregatedTrueUp(AggregatedTrueUp $aggregatedTrueUp): self
591.     {
592.         if ($this->aggregatedTrueUps->removeElement($aggregatedTrueUp)) {
593.             // set the owning side to null (unless already changed)
594.             if ($aggregatedTrueUp->getUser() === $this) {
595.                 $aggregatedTrueUp->setUser(null);
596.             }
597.         }
599.         return $this;
600.     }
602.     public static function getUserRoleChoices()
603.     {
604.         return [
605.             self::ROLE_USER => self::ROLE_USER,
606.             self::ROLE_ADMIN => self::ROLE_ADMIN
607.         ];
608.     }
610.     public function getFirstName(): ?string
611.     {
612.         return $this->firstName;
613.     }
615.     public function setFirstName(?string $firstName): static
616.     {
617.         $this->firstName = $firstName;
619.         return $this;
620.     }
622.     public function getLastName(): ?string
623.     {
624.         return $this->lastName;
625.     }
627.     public function setLastName(?string $lastName): static
628.     {
629.         $this->lastName = $lastName;
631.         return $this;
632.     }
634.     /**
635.      * @return Collection<int, Position>
636.      */
637.     public function getPositions(): Collection
638.     {
639.         return $this->positions;
640.     }
642.     public function addPosition(Position $position): static
643.     {
644.         if (!$this->positions->contains($position)) {
645.             $this->positions->add($position);
646.             $position->setUser($this);
647.         }
649.         return $this;
650.     }
652.     public function removePosition(Position $position): static
653.     {
654.         if ($this->positions->removeElement($position)) {
655.             // set the owning side to null (unless already changed)
656.             if ($position->getUser() === $this) {
657.                 $position->setUser(null);
658.             }
659.         }
661.         return $this;
662.     }
664.     public function getManagerName(): ?string
665.     {
666.         return $this->managerName;
667.     }
669.     public function setManagerName(?string $managerName): static
670.     {
671.         $this->managerName = $managerName;
673.         return $this;
674.     }
676.     public function getTitleRole(): ?string
677.     {
678.         return $this->titleRole;
679.     }
681.     public function setTitleRole(?string $titleRole): self
682.     {
683.         $this->titleRole = $titleRole;
685.         return $this;
686.     }
688.     public function getGuaranteeAmount(): ?float
689.     {
690.         return $this->guaranteeAmount;
691.     }
693.     public function setGuaranteeAmount(?float $guaranteeAmount): self
694.     {
695.         $this->guaranteeAmount = $guaranteeAmount;
697.         return $this;
698.     }
700.     public function getGuaranteeAmountUnitType(): ?UnitType
701.     {
702.         return $this->guaranteeAmountUnitType;
703.     }
705.     public function setGuaranteeAmountUnitType(?UnitType $guaranteeAmountUnitType): self
706.     {
707.         $this->guaranteeAmountUnitType = $guaranteeAmountUnitType;
709.         return $this;
710.     }
712.     public function getGuaranteePeriodUnitType(): ?UnitType
713.     {
714.         return $this->guaranteePeriodUnitType;
715.     }
717.     public function setGuaranteePeriodUnitType(?UnitType $guaranteePeriodUnitType): self
718.     {
719.         $this->guaranteePeriodUnitType = $guaranteePeriodUnitType;
721.         return $this;
722.     }
724.     /**
725.      * @return Collection<int, Commission>
726.      */
727.     public function getCommissions(): Collection
728.     {
729.         return $this->commissions;
730.     }
732.     public function addCommission(Commission $commission): static
733.     {
734.         if (!$this->commissions->contains($commission)) {
735.             $this->commissions->add($commission);
736.             $commission->setUser($this);
737.         }
739.         return $this;
740.     }
742.     public function removeCommission(Commission $commission): static
743.     {
744.         if ($this->commissions->removeElement($commission)) {
745.             // set the owning side to null (unless already changed)
746.             if ($commission->getUser() === $this) {
747.                 $commission->setUser(null);
748.             }
749.         }
751.         return $this;
752.     }
754.     /**
755.      * @return Collection<int, Credit>
756.      */
757.     public function getCredits(): Collection
758.     {
759.         return $this->credits;
760.     }
762.     public function addCredit(Credit $credit): static
763.     {
764.         if (!$this->credits->contains($credit)) {
765.             $this->credits->add($credit);
766.             $credit->setUser($this);
767.         }
769.         return $this;
770.     }
772.     public function removeCredit(Credit $credit): static
773.     {
774.         if ($this->credits->removeElement($credit)) {
775.             // set the owning side to null (unless already changed)
776.             if ($credit->getUser() === $this) {
777.                 $credit->setUser(null);
778.             }
779.         }
781.         return $this;
782.     }
784.     public function getMiddleName(): ?string
785.     {
786.         return $this->middleName;
787.     }
789.     public function setMiddleName(?string $middleName): static
790.     {
791.         $this->middleName = $middleName;
793.         return $this;
794.     }
796.     public function getEffectiveStartDate(): ?\DateTimeInterface
797.     {
798.         return $this->effectiveStartDate;
799.     }
801.     public function setEffectiveStartDate(?\DateTimeInterface $effectiveStartDate): static
802.     {
803.         $this->effectiveStartDate = $effectiveStartDate;
805.         return $this;
806.     }
808.     public function getDescription(): ?string
809.     {
810.         return $this->description;
811.     }
813.     public function setDescription(?string $description): static
814.     {
815.         $this->description = $description;
817.         return $this;
818.     }
820.     public function getHireDate(): ?\DateTimeInterface
821.     {
822.         return $this->hireDate;
823.     }
825.     public function setHireDate(?\DateTimeInterface $hireDate): static
826.     {
827.         $this->hireDate = $hireDate;
829.         return $this;
830.     }
832.     public function getTerminationDate(): ?\DateTimeInterface
833.     {
834.         return $this->terminationDate;
835.     }
837.     public function setTerminationDate(?\DateTimeInterface $terminationDate): static
838.     {
839.         $this->terminationDate = $terminationDate;
841.         return $this;
842.     }
844.     public function getPersonalTarget(): ?float
845.     {
846.         return $this->personalTarget;
847.     }
849.     public function setPersonalTarget(float $personalTarget): static
850.     {
851.         $this->personalTarget = $personalTarget;
853.         return $this;
854.     }
856.     public function getProratedPersonalTarget(): ?float
857.     {
858.         return $this->proratedPersonalTarget;
859.     }
861.     public function setProratedPersonalTarget(float $proratedPersonalTarget): static
862.     {
863.         $this->proratedPersonalTarget = $proratedPersonalTarget;
865.         return $this;
866.     }
868.     public function getPersonalCurrency(): ?Currency
869.     {
870.         return $this->personalCurrency;
871.     }
873.     public function setPersonalCurrency(Currency $personalCurrency): static
874.     {
875.         $this->personalCurrency = $personalCurrency;
877.         return $this;
878.     }
880.     public function getProratedSalary(): ?float
881.     {
882.         return $this->proratedSalary;
883.     }
885.     public function setProratedSalary(float $proratedSalary): static
886.     {
887.         $this->proratedSalary = $proratedSalary;
889.         return $this;
890.     }
892.     public function getPaymentCurrency(): ?Currency
893.     {
894.         return $this->paymentCurrency;
895.     }
897.     public function setPaymentCurrency(Currency $paymentCurrency): static
898.     {
899.         $this->paymentCurrency = $paymentCurrency;
901.         return $this;
902.     }
904.     public function getSalary(): ?FLOAT
905.     {
906.         return $this->salary;
907.     }
909.     public function setSalary(float $salary): static
910.     {
911.         $this->salary = $salary;
913.         return $this;
914.     }
916.     public function getSalaryCurrency(): ?Currency
917.     {
918.         return $this->salaryCurrency;
919.     }
921.     public function setSalaryCurrency(Currency $salaryCurrency): static
922.     {
923.         $this->salaryCurrency = $salaryCurrency;
925.         return $this;
926.     }
930.     /**
931.      * @return Collection<int, ManualPayment>
932.      */
933.     public function getManualPayments(): Collection
934.     {
935.         return $this->manualPayments;
936.     }
938.     public function addManualPayment(ManualPayment $manualPayment): static
939.     {
940.         if (!$this->manualPayments->contains($manualPayment)) {
941.             $this->manualPayments->add($manualPayment);
942.             $manualPayment->setUser($this);
943.         }
945.         return $this;
946.     }
948.     public function removeManualPayment(ManualPayment $manualPayment): static
949.     {
950.         if ($this->manualPayments->removeElement($manualPayment)) {
951.             // set the owning side to null (unless already changed)
952.             if ($manualPayment->getUser() === $this) {
953.                 $manualPayment->setUser(null);
954.             }
955.         }
957.         return $this;
958.     }
960.     public function getTitle(): ?Title
961.     {
962.         return $this->title;
963.     }
965.     public function setTitle(?Title $title): static
966.     {
967.         $this->title = $title;
969.         return $this;
970.     }
972.     public function getPositionTitleByDate($date)
973.     {
974.         if ($this->positions->isEmpty()) {
975.             return $this->getTitle();
976.         }
978.         $positions = $this->positions->toArray();
980.         usort($positions, function($a, $b) {
981.             return $b->getEffectiveStartDate() <=> $a->getEffectiveStartDate();
982.         });
984.         foreach ($positions as $position) {
985.             if ($position->getEffectiveStartDate() <= $date) {
986.                 return $position->getTitle();
987.             }
988.         }
990.         return $this->getTitle();
991.     }
993.     /**
994.      * @return Collection<int, OrderAssignment>
995.      */
996.     public function getOrderAssignments(): Collection
997.     {
998.         return $this->orderAssignments;
999.     }
1001.     public function addOrderAssignment(OrderAssignment $orderAssignment): static
1002.     {
1003.         if (!$this->orderAssignments->contains($orderAssignment)) {
1004.             $this->orderAssignments->add($orderAssignment);
1005.             $orderAssignment->setUser($this);
1006.         }
1008.         return $this;
1009.     }
1011.     public function removeOrderAssignment(OrderAssignment $orderAssignment): static
1012.     {
1013.         if ($this->orderAssignments->removeElement($orderAssignment)) {
1014.             // set the owning side to null (unless already changed)
1015.             if ($orderAssignment->getUser() === $this) {
1016.                 $orderAssignment->setUser(null);
1017.             }
1018.         }
1020.         return $this;
1021.     }
1023.     /**
1024.      * @return Collection<int, EmployeeRepCode>
1025.      */
1026.     public function getEmployeeRepCodes(): Collection
1027.     {
1028.         return $this->employeeRepCodes;
1029.     }
1031.     public function addEmployeeRepCode(EmployeeRepCode $employeeRepCode): static
1032.     {
1033.         if (!$this->employeeRepCodes->contains($employeeRepCode)) {
1034.             $this->employeeRepCodes->add($employeeRepCode);
1035.             $employeeRepCode->setUser($this);
1036.         }
1038.         return $this;
1039.     }
1041.     public function removeEmployeeRepCode(EmployeeRepCode $employeeRepCode): static
1042.     {
1043.         if ($this->employeeRepCodes->removeElement($employeeRepCode)) {
1044.             // set the owning side to null (unless already changed)
1045.             if ($employeeRepCode->getUser() === $this) {
1046.                 $employeeRepCode->setUser(null);
1047.             }
1048.         }
1050.         return $this;
1051.     }
1053.     /**
1054.      * @return Collection<int, NamedRelationshipPosition>
1055.      */
1056.     public function getFromNamedRelationshipPositions(): Collection
1057.     {
1058.         return $this->fromNamedRelationshipPositions;
1059.     }
1061.     public function addFromNamedRelationshipPosition(NamedRelationshipPosition $fromNamedRelationshipPosition): static
1062.     {
1063.         if (!$this->fromNamedRelationshipPositions->contains($fromNamedRelationshipPosition)) {
1064.             $this->fromNamedRelationshipPositions->add($fromNamedRelationshipPosition);
1065.             $fromNamedRelationshipPosition->setFromUser($this);
1066.         }
1068.         return $this;
1069.     }
1071.     public function removeFromNamedRelationshipPosition(NamedRelationshipPosition $fromNamedRelationshipPosition): static
1072.     {
1073.         if ($this->fromNamedRelationshipPositions->removeElement($fromNamedRelationshipPosition)) {
1074.             // set the owning side to null (unless already changed)
1075.             if ($fromNamedRelationshipPosition->getFromUser() === $this) {
1076.                 $fromNamedRelationshipPosition->setFromUser(null);
1077.             }
1078.         }
1080.         return $this;
1081.     }
1083.     /**
1084.      * @return Collection<int, NamedRelationshipPosition>
1085.      */
1086.     public function getToNamedRelationshipPositions(): Collection
1087.     {
1088.         return $this->toNamedRelationshipPositions;
1089.     }
1091.     public function addToNamedRelationshipPosition(NamedRelationshipPosition $toNamedRelationshipPosition): static
1092.     {
1093.         if (!$this->toNamedRelationshipPositions->contains($toNamedRelationshipPosition)) {
1094.             $this->toNamedRelationshipPositions->add($toNamedRelationshipPosition);
1095.             $toNamedRelationshipPosition->setToUser($this);
1096.         }
1098.         return $this;
1099.     }
1101.     public function removeToNamedRelationshipPosition(NamedRelationshipPosition $toNamedRelationshipPosition): static
1102.     {
1103.         if ($this->toNamedRelationshipPositions->removeElement($toNamedRelationshipPosition)) {
1104.             // set the owning side to null (unless already changed)
1105.             if ($toNamedRelationshipPosition->getToUser() === $this) {
1106.                 $toNamedRelationshipPosition->setToUser(null);
1107.             }
1108.         }
1110.         return $this;
1111.     }
1113.     /**
1114.      * @return Collection<int, LookUpTable>
1115.      */
1116.     public function getLookUpTables(): Collection
1117.     {
1118.         return $this->lookUpTables;
1119.     }
1121.     public function addLookUpTable(LookUpTable $lookUpTable): static
1122.     {
1123.         if (!$this->lookUpTables->contains($lookUpTable)) {
1124.             $this->lookUpTables->add($lookUpTable);
1125.             $lookUpTable->setAssignedUser($this);
1126.         }
1128.         return $this;
1129.     }
1131.     public function removeLookUpTable(LookUpTable $lookUpTable): static
1132.     {
1133.         if ($this->lookUpTables->removeElement($lookUpTable)) {
1134.             // set the owning side to null (unless already changed)
1135.             if ($lookUpTable->getAssignedUser() === $this) {
1136.                 $lookUpTable->setAssignedUser(null);
1137.             }
1138.         }
1140.         return $this;
1141.     }
1143.     /**
1144.      * @return Collection<int, RateTableAssignment>
1145.      */
1146.     public function getRateTableAssignments(): Collection
1147.     {
1148.         return $this->rateTableAssignments;
1149.     }
1151.     public function addRateTableAssignment(RateTableAssignment $rateTableAssignment): static
1152.     {
1153.         if (!$this->rateTableAssignments->contains($rateTableAssignment)) {
1154.             $this->rateTableAssignments->add($rateTableAssignment);
1155.             $rateTableAssignment->setUser($this);
1156.         }
1158.         return $this;
1159.     }
1161.     public function removeRateTableAssignment(RateTableAssignment $rateTableAssignment): static
1162.     {
1163.         if ($this->rateTableAssignments->removeElement($rateTableAssignment)) {
1164.             // set the owning side to null (unless already changed)
1165.             if ($rateTableAssignment->getUser() === $this) {
1166.                 $rateTableAssignment->setUser(null);
1167.             }
1168.         }
1170.         return $this;
1171.     }
1173.     /**
1174.      * @return Collection<int, RuleCondition>
1175.      */
1176.     public function getRuleConditions(): Collection
1177.     {
1178.         return $this->ruleConditions;
1179.     }
1181.     public function addRuleCondition(RuleCondition $ruleCondition): static
1182.     {
1183.         if (!$this->ruleConditions->contains($ruleCondition)) {
1184.             $this->ruleConditions->add($ruleCondition);
1185.             $ruleCondition->setUser($this);
1186.         }
1188.         return $this;
1189.     }
1191.     public function removeRuleCondition(RuleCondition $ruleCondition): static
1192.     {
1193.         if ($this->ruleConditions->removeElement($ruleCondition)) {
1194.             // set the owning side to null (unless already changed)
1195.             if ($ruleCondition->getUser() === $this) {
1196.                 $ruleCondition->setUser(null);
1197.             }
1198.         }
1200.         return $this;
1201.     }
1203.     /**
1204.      * @return Collection<int, Hierarchy>
1205.      */
1206.     public function getHierarchies(): Collection
1207.     {
1208.         return $this->hierarchies;
1209.     }
1211.     public function addHierarchy(Hierarchy $hierarchy): static
1212.     {
1213.         if (!$this->hierarchies->contains($hierarchy)) {
1214.             $this->hierarchies->add($hierarchy);
1215.             $hierarchy->setUser($this);
1216.         }
1218.         return $this;
1219.     }
1221.     public function removeHierarchy(Hierarchy $hierarchy): static
1222.     {
1223.         if ($this->hierarchies->removeElement($hierarchy)) {
1224.             // set the owning side to null (unless already changed)
1225.             if ($hierarchy->getUser() === $this) {
1226.                 $hierarchy->setUser(null);
1227.             }
1228.         }
1230.         return $this;
1231.     }
1233.     /**
1234.      * @return Collection<int, Hierarchy>
1235.      */
1236.     public function getParentHierarchies(): Collection
1237.     {
1238.         return $this->parentHierarchies;
1239.     }
1241.     public function addParentHierarchy(Hierarchy $parentHierarchy): static
1242.     {
1243.         if (!$this->parentHierarchies->contains($parentHierarchy)) {
1244.             $this->parentHierarchies->add($parentHierarchy);
1245.             $parentHierarchy->setParentUser($this);
1246.         }
1248.         return $this;
1249.     }
1251.     public function removeParentHierarchy(Hierarchy $parentHierarchy): static
1252.     {
1253.         if ($this->parentHierarchies->removeElement($parentHierarchy)) {
1254.             // set the owning side to null (unless already changed)
1255.             if ($parentHierarchy->getParentUser() === $this) {
1256.                 $parentHierarchy->setParentUser(null);
1257.             }
1258.         }
1260.         return $this;
1261.     }
1264.     public function getInitials(): string
1265.     {
1266.         $firstInitial = '';
1267.         $lastInitial = '';
1269.         if($this->getFirstName()) {
1270.             $firstInitial = mb_substr($this->getFirstName(), 0, 1);
1271.         }
1273.         if($this->getLastName()) {
1274.             $lastInitial = mb_substr($this->getLastName(), 0, 1);
1275.         }
1276.         return  $firstInitial . $lastInitial;
1278.     }
1281.     public function isAdmin(): bool
1282.     {
1283.         return $this->hasRole(self::ROLE_SUPER_ADMIN) || $this->hasRole(self::ROLE_ADMIN);
1284.     }
1286.     public function getEarningCommissionsStartDate(): ?\DateTimeInterface
1287.     {
1288.         return $this->earningCommissionsStartDate;
1289.     }
1291.     public function setEarningCommissionsStartDate(?\DateTimeInterface $earningCommissionsStartDate): static
1292.     {
1293.         $this->earningCommissionsStartDate = $earningCommissionsStartDate;
1295.         return $this;
1296.     }
1298.     public function getEarningCommissionsPeriod(): ?int
1299.     {
1300.         return $this->earningCommissionsPeriod;
1301.     }
1303.     public function setEarningCommissionsPeriod(?int $earningCommissionsPeriod): static
1304.     {
1305.         $this->earningCommissionsPeriod = $earningCommissionsPeriod;
1307.         return $this;
1308.     }
1310.     public function getGuaranteeAlertSentAt(): ?\DateTimeInterface
1311.     {
1312.         return $this->guaranteeAlertSentAt;
1313.     }
1315.     public function setGuaranteeAlertSentAt(?\DateTimeInterface $guaranteeAlertSentAt): static
1316.     {
1317.         $this->guaranteeAlertSentAt = $guaranteeAlertSentAt;
1319.         return $this;
1320.     }
1322.     public function getRegion(): ?Region
1323.     {
1324.         return $this->region;
1325.     }
1327.     public function setRegion(?Region $region): static
1328.     {
1329.         $this->region = $region;
1331.         return $this;
1332.     }
1334.     /**
1335.      * @return Collection<int, UserLogin>
1336.      */
1337.     public function getUserLogins(): Collection
1338.     {
1339.         return $this->userLogins;
1340.     }
1342.     public function addUserLogin(UserLogin $userLogin): static
1343.     {
1344.         if (!$this->userLogins->contains($userLogin)) {
1345.             $this->userLogins->add($userLogin);
1346.             $userLogin->setUser($this);
1347.         }
1349.         return $this;
1350.     }
1352.     public function removeUserLogin(UserLogin $userLogin): static
1353.     {
1354.         if ($this->userLogins->removeElement($userLogin)) {
1355.             // set the owning side to null (unless already changed)
1356.             if ($userLogin->getUser() === $this) {
1357.                 $userLogin->setUser(null);
1358.             }
1359.         }
1361.         return $this;
1362.     }
1364.     /**
1365.      * @return Collection<int, AdMapping>
1366.      */
1367.     public function getAdMappings(): Collection
1368.     {
1369.         return $this->adMappings;
1370.     }
1372.     public function addAdMapping(AdMapping $adMapping): static
1373.     {
1374.         if (!$this->adMappings->contains($adMapping)) {
1375.             $this->adMappings->add($adMapping);
1376.             $adMapping->setUser($this);
1377.         }
1379.         return $this;
1380.     }
1382.     public function removeAdMapping(AdMapping $adMapping): static
1383.     {
1384.         if ($this->adMappings->removeElement($adMapping)) {
1385.             // set the owning side to null (unless already changed)
1386.             if ($adMapping->getUser() === $this) {
1387.                 $adMapping->setUser(null);
1388.             }
1389.         }
1391.         return $this;
1392.     }
1394.     /**
1395.      * @return Collection<int, UserRegion>
1396.      */
1397.     public function getUserRegions(): Collection
1398.     {
1399.         return $this->userRegions;
1400.     }
1402.     public function addUserRegion(UserRegion $userRegion): static
1403.     {
1404.         if (!$this->userRegions->contains($userRegion)) {
1405.             $this->userRegions->add($userRegion);
1406.             $userRegion->setUser($this);
1407.         }
1409.         return $this;
1410.     }
1412.     public function removeUserRegion(UserRegion $userRegion): static
1413.     {
1414.         if ($this->userRegions->removeElement($userRegion)) {
1415.             // set the owning side to null (unless already changed)
1416.             if ($userRegion->getUser() === $this) {
1417.                 $userRegion->setUser(null);
1418.             }
1419.         }
1421.         return $this;
1422.     }
1424.     /**
1425.      * @return Collection<int, CommissionShareRule>
1426.      */
1427.     public function getCommissionShareRulesTo(): Collection
1428.     {
1429.         return $this->commissionShareRulesTo;
1430.     }
1432.     public function addCommissionShareRulesTo(CommissionShareRule $commissionShareRulesTo): static
1433.     {
1434.         if (!$this->commissionShareRulesTo->contains($commissionShareRulesTo)) {
1435.             $this->commissionShareRulesTo->add($commissionShareRulesTo);
1436.             $commissionShareRulesTo->setToUser($this);
1437.         }
1439.         return $this;
1440.     }
1442.     public function removeCommissionShareRulesTo(CommissionShareRule $commissionShareRulesTo): static
1443.     {
1444.         if ($this->commissionShareRulesTo->removeElement($commissionShareRulesTo)) {
1445.             // set the owning side to null (unless already changed)
1446.             if ($commissionShareRulesTo->getToUser() === $this) {
1447.                 $commissionShareRulesTo->setToUser(null);
1448.             }
1449.         }
1451.         return $this;
1452.     }
1454.     public function getLeaveOfAbsenceStartDate(): ?\DateTimeInterface
1455.     {
1456.         return $this->leaveOfAbsenceStartDate;
1457.     }
1459.     public function setLeaveOfAbsenceStartDate(?\DateTimeInterface $leaveOfAbsenceStartDate): static
1460.     {
1461.         $this->leaveOfAbsenceStartDate = $leaveOfAbsenceStartDate;
1463.         return $this;
1464.     }
1466.     public function getLeaveOfAbsenceEndDate(): ?\DateTimeInterface
1467.     {
1468.         return $this->leaveOfAbsenceEndDate;
1469.     }
1471.     public function setLeaveOfAbsenceEndDate(?\DateTimeInterface $leaveOfAbsenceEndDate): static
1472.     {
1473.         $this->leaveOfAbsenceEndDate = $leaveOfAbsenceEndDate;
1475.         return $this;
1476.     }
1478.     public function isOnLeaveOfAbsence(?\DateTimeInterface $date = null): bool
1479.     {
1480.         if ($this->employeeStatus !== EmployeeStatus::LEAVE_OF_ABSENCE) {
1481.             return false;
1482.         }
1484.         if ($this->leaveOfAbsenceStartDate === null || $this->leaveOfAbsenceEndDate === null) {
1485.             return false;
1486.         }
1488.         $checkDate = $date ?? new \DateTime();
1490.         return $checkDate >= $this->leaveOfAbsenceStartDate && $checkDate <= $this->leaveOfAbsenceEndDate;
1491.     }
1492. }