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;
157.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
158.     private ?\DateTimeInterface $salaryChangeDate = null;
162.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ManualPayment::class)]
163.     private Collection $manualPayments;
165.     #[ORM\ManyToOne(inversedBy: 'users', fetch: 'EAGER')]
166.     private ?Title $title = null;
168.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: OrderAssignment::class)]
169.     private Collection $orderAssignments;
171.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: EmployeeRepCode::class)]
172.     private Collection $employeeRepCodes;
174.     #[ORM\OneToMany(mappedBy: 'fromUser', targetEntity: NamedRelationshipPosition::class)]
175.     private Collection $fromNamedRelationshipPositions;
177.     #[ORM\OneToMany(mappedBy: 'toUser', targetEntity: NamedRelationshipPosition::class)]
178.     private Collection $toNamedRelationshipPositions;
180.     #[ORM\OneToMany(mappedBy: 'assignedUser', targetEntity: LookUpTable::class)]
181.     private Collection $lookUpTables;
183.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: RateTableAssignment::class)]
184.     private Collection $rateTableAssignments;
186.     #[ORM\OneToMany(mappedBy: 'User', targetEntity: RuleCondition::class)]
187.     private Collection $ruleConditions;
189.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Hierarchy::class, cascade: ['persist', 'remove'])]
190.     private Collection $hierarchies;
192.     #[ORM\OneToMany(mappedBy: 'parentUser', targetEntity: Hierarchy::class)]
193.     #[ORM\OrderBy(['effectiveStartDate' => 'ASC'])]
194.     private Collection $parentHierarchies;
196.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
197.     private ?\DateTimeInterface $earningCommissionsStartDate = null;
199.     #[ORM\Column(nullable: true)]
200.     private ?int $earningCommissionsPeriod = null;
202.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
203.     private ?\DateTimeInterface $guaranteeAlertSentAt = null;
205.     #[ORM\ManyToOne(inversedBy: 'users', fetch: 'EAGER')]
206.     private ?Region $region = null;
208.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserLogin::class)]
209.     private Collection $userLogins;
211.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: AdMapping::class)]
212.     private Collection $adMappings;
214.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserRegion::class, cascade: ['persist', 'remove'])]
215.     private Collection $userRegions;
217.     #[ORM\OneToMany(mappedBy: 'toUser', targetEntity: CommissionShareRule::class)]
218.     private Collection $commissionShareRulesTo;
220.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
221.     private ?\DateTimeInterface $leaveOfAbsenceStartDate = null;
223.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
224.     private ?\DateTimeInterface $leaveOfAbsenceEndDate = null;
226.     public function __construct()
227.     {
228.         $this->userPaymentPeriods = new ArrayCollection();
229.         $this->aggregatedTrueUps = new ArrayCollection();
230.         $this->positions = new ArrayCollection();
231.         $this->commissions = new ArrayCollection();
232.         $this->credits = new ArrayCollection();
233.         $this->manualPayments = new ArrayCollection();
234.         $this->orderAssignments = new ArrayCollection();
235.         $this->employeeRepCodes = new ArrayCollection();
236.         $this->fromNamedRelationshipPositions = new ArrayCollection();
237.         $this->toNamedRelationshipPositions = new ArrayCollection();
238.         $this->lookUpTables = new ArrayCollection();
239.         $this->rateTableAssignments = new ArrayCollection();
240.         $this->ruleConditions = new ArrayCollection();
241.         $this->hierarchies = new ArrayCollection();
242.         $this->parentHierarchies = new ArrayCollection();
243.         $this->userLogins = new ArrayCollection();
244.         $this->adMappings = new ArrayCollection();
245.         $this->userRegions = new ArrayCollection();
246.         $this->hireDate = new \DateTime();
247.         $this->commissionShareRulesTo = new ArrayCollection();
248.     }
250.     public function getId(): ?int
251.     {
252.         return $this->id;
253.     }
255.     public function getEmail(): ?string
256.     {
257.         return $this->email;
258.     }
260.     public function setEmail(string $email): self
261.     {
262.         $this->email = $email;
264.         return $this;
265.     }
267.     /**
268.      * A visual identifier that represents this user.
269.      *
270.      * @see UserInterface
271.      */
272.     public function getUserIdentifier(): string
273.     {
274.         return (string) $this->email;
275.     }
277.     /**
278.      * @see UserInterface
279.      */
280.     public function getRoles(): array
281.     {
282.         $roles = $this->roles;
283.         // guarantee every user at least has ROLE_USER
284.         $roles[] = 'ROLE_USER';
286.         return array_unique($roles);
287.     }
289.     public function setRoles(array $roles): self
290.     {
291.         $this->roles = $roles;
293.         return $this;
294.     }
296.     public function addRole($role): self
297.     {
298.         $roles = $this->roles;
299.         $roles[] = $role;
300.         $this->setRoles(array_unique($roles));
301.         return $this;
302.     }
304.     public static function getRolesList($secure = false): array
305.     {
306.         $roles = [
307.             self::ROLE_USER => 'User',
308.             self::ROLE_SUPER_ADMIN => 'Super Admin',
309.             self::ROLE_ADMIN => 'Admin',
310.             self::ROLE_INDIVIDUAL_PAYEE => 'Individual Payee',
311.             self::ROLE_MANAGER => 'Manager',
312.             self::ROLE_EXECUTIVE => 'Executive',
313.         ];
316.         return $roles;
317.     }
319.     public function getRolesLabels(): string
320.     {
321.         $rolesList = self::getRolesList();
322.         $roles = [];
323.         foreach ($this->getRoles() as $role) {
324.             $label = 'label-info';
326.             if ($role === self::ROLE_SUPER_ADMIN){
327.                 $label = 'label-warning';
328.             }
329.             if ($role === self::ROLE_ADMIN){
330.                 $label = 'label-primary';
331.             }
332.             if ($role !== self::ROLE_DEFAULT) {
333.                 $roles[] = "<span class='label {$label}'>{$rolesList[$role]}</span>&nbsp;";
334.             }
335.         }
336.         return implode(' ', $roles);
337.     }
338.     /**
339.      * {@inheritdoc}
340.      */
341.     public function hasRole($role): bool
342.     {
343.         return in_array(strtoupper($role), $this->getRoles(), true);
344.     }
345.     /**
346.      * @see PasswordAuthenticatedUserInterface
347.      */
348.     public function getPassword(): ?string
349.     {
350.         return $this->password;
351.     }
353.     public function setPassword(string $password): self
354.     {
355.         $this->password = $password;
357.         return $this;
358.     }
360.     /**
361.      * @see UserInterface
362.      */
363.     public function eraseCredentials()
364.     {
365.         // If you store any temporary, sensitive data on the user, clear it here
366.         // $this->plainPassword = null;
367.     }
369.     public function isIncentAccess(): ?bool
370.     {
371.         return $this->incentAccess;
372.     }
374.     public function setIncentAccess(bool $incentAccess): self
375.     {
376.         $this->incentAccess = $incentAccess;
378.         return $this;
379.     }
381.     public function getFullName(): ?string
382.     {
383.         $string = sprintf('%s %s', $this->firstName, $this->lastName);
385.         if($this->getEmployeeID()){
386.             $string = sprintf('%s (%s)', $string, $this->getEmployeeID());
387.         }
388.         return $string;
389.     }
393.     public function getGroupName(): ?GroupName
394.     {
395.         return $this->groupName;
396.     }
398.     public function setGroupName(?GroupName $groupName): self
399.     {
400.         $this->groupName = $groupName;
402.         return $this;
403.     }
406.     public function getManager(): ?self
407.     {
408.         return $this->manager;
409.     }
411.     public function setManager(?self $manager): self
412.     {
413.         $this->manager = $manager;
415.         return $this;
416.     }
418.     public function isCreditEligible(): ?bool
419.     {
420.         return $this->creditEligible;
421.     }
423.     public function setCreditEligible(?bool $creditEligible): self
424.     {
425.         $this->creditEligible = $creditEligible;
427.         return $this;
428.     }
430.     public function isCommissionEligible(): ?bool
431.     {
432.         return $this->commissionEligible;
433.     }
435.     public function setCommissionEligible(?bool $commissionEligible): self
436.     {
437.         $this->commissionEligible = $commissionEligible;
439.         return $this;
440.     }
442.     public function getEmployeeID(): ?string
443.     {
444.         return $this->employeeID;
445.     }
447.     public function setEmployeeID(?string $employeeID): self
448.     {
449.         $this->employeeID = $employeeID;
451.         return $this;
452.     }
454.     public function getPlan(): ?Plan
455.     {
456.         return $this->plan;
457.     }
459.     public function setPlan(?Plan $plan): self
460.     {
461.         $this->plan = $plan;
463.         return $this;
464.     }
467.     public function getEmployeeStatus(): ?EmployeeStatus
468.     {
469.         return $this->employeeStatus;
470.     }
472.     public function setEmployeeStatus(?EmployeeStatus $employeeStatus): self
473.     {
474.         $this->employeeStatus = $employeeStatus;
476.         return $this;
477.     }
479.     public function __toString()
480.     {
481.         return $this->getFullName() ?: $this->email;
482.     }
484.     public function getGuaranteePeriod(): ?int
485.     {
486.         return $this->guaranteePeriod;
487.     }
489.     public function setGuaranteePeriod(?int $guaranteePeriod): self
490.     {
491.         $this->guaranteePeriod = $guaranteePeriod;
493.         // reset alert sent at
494.         $this->guaranteeAlertSentAt = null;
495.         return $this;
496.     }
498.     public function getGuaranteeStartDate(): ?\DateTimeInterface
499.     {
500.         return $this->guaranteeStartDate;
501.     }
503.     public function setGuaranteeStartDate(?\DateTimeInterface $guaranteeStartDate): self
504.     {
505.         $this->guaranteeStartDate = $guaranteeStartDate;
507.         // reset alert sent at
508.         $this->guaranteeAlertSentAt = null;
510.         return $this;
511.     }
514.     public function getGuaranteeEndDate(): ?\DateTimeInterface
515.     {
516.         $startDate = clone $this->getGuaranteeStartDate();
517.         if($startDate){
518.             $startDate->modify("+{$this->getGuaranteePeriod()} months")->sub(new \DateInterval('P1D'));
519.         }
521.         return $startDate;
522.     }
525.     /**
526.      * @return Collection<int, UserPaymentPeriod>
527.      */
528.     public function getFilteredUserPaymentPeriods(\DateTime $start, \DateTime $end): Collection
529.     {
530.         return $this->userPaymentPeriods;
531.     }
532.     /**
533.      * @return Collection<int, UserPaymentPeriod>
534.      */
535.     public function getUserPaymentPeriods(): Collection
536.     {
537.         return $this->userPaymentPeriods;
538.     }
540.     public function addUserPaymentPeriod(UserPaymentPeriod $userPaymentPeriod): self
541.     {
542.         if (!$this->userPaymentPeriods->contains($userPaymentPeriod)) {
543.             $this->userPaymentPeriods->add($userPaymentPeriod);
544.             $userPaymentPeriod->setUser($this);
545.         }
547.         return $this;
548.     }
550.     public function removeUserPaymentPeriod(UserPaymentPeriod $userPaymentPeriod): self
551.     {
552.         if ($this->userPaymentPeriods->removeElement($userPaymentPeriod)) {
553.             // set the owning side to null (unless already changed)
554.             if ($userPaymentPeriod->getUser() === $this) {
555.                 $userPaymentPeriod->setUser(null);
556.             }
557.         }
559.         return $this;
560.     }
562.     public function getUserPaymentPeriodsByDateRange(\DateTime $start, \DateTime $end)
563.     {
564.         $upp = [];
565.         foreach($this->userPaymentPeriods as $cand) {
566.             if ($cand->getPaymentPeriod()->getStart() >= $start && $cand->getPaymentPeriod()->getEnd() <= $end) {
567.                 $upp[] = $cand;
568.             }
569.         }
571.         return $upp;
573.     }
575.     /**
576.      * @return Collection<int, AggregatedTrueUp>
577.      */
578.     public function getAggregatedTrueUps(): Collection
579.     {
580.         return $this->aggregatedTrueUps;
581.     }
583.     public function addAggregatedTrueUp(AggregatedTrueUp $aggregatedTrueUp): self
584.     {
585.         if (!$this->aggregatedTrueUps->contains($aggregatedTrueUp)) {
586.             $this->aggregatedTrueUps->add($aggregatedTrueUp);
587.             $aggregatedTrueUp->setUser($this);
588.         }
590.         return $this;
591.     }
593.     public function removeAggregatedTrueUp(AggregatedTrueUp $aggregatedTrueUp): self
594.     {
595.         if ($this->aggregatedTrueUps->removeElement($aggregatedTrueUp)) {
596.             // set the owning side to null (unless already changed)
597.             if ($aggregatedTrueUp->getUser() === $this) {
598.                 $aggregatedTrueUp->setUser(null);
599.             }
600.         }
602.         return $this;
603.     }
605.     public static function getUserRoleChoices()
606.     {
607.         return [
608.             self::ROLE_USER => self::ROLE_USER,
609.             self::ROLE_ADMIN => self::ROLE_ADMIN
610.         ];
611.     }
613.     public function getFirstName(): ?string
614.     {
615.         return $this->firstName;
616.     }
618.     public function setFirstName(?string $firstName): static
619.     {
620.         $this->firstName = $firstName;
622.         return $this;
623.     }
625.     public function getLastName(): ?string
626.     {
627.         return $this->lastName;
628.     }
630.     public function setLastName(?string $lastName): static
631.     {
632.         $this->lastName = $lastName;
634.         return $this;
635.     }
637.     /**
638.      * @return Collection<int, Position>
639.      */
640.     public function getPositions(): Collection
641.     {
642.         return $this->positions;
643.     }
645.     public function addPosition(Position $position): static
646.     {
647.         if (!$this->positions->contains($position)) {
648.             $this->positions->add($position);
649.             $position->setUser($this);
650.         }
652.         return $this;
653.     }
655.     public function removePosition(Position $position): static
656.     {
657.         if ($this->positions->removeElement($position)) {
658.             // set the owning side to null (unless already changed)
659.             if ($position->getUser() === $this) {
660.                 $position->setUser(null);
661.             }
662.         }
664.         return $this;
665.     }
667.     public function getManagerName(): ?string
668.     {
669.         return $this->managerName;
670.     }
672.     public function setManagerName(?string $managerName): static
673.     {
674.         $this->managerName = $managerName;
676.         return $this;
677.     }
679.     public function getTitleRole(): ?string
680.     {
681.         return $this->titleRole;
682.     }
684.     public function setTitleRole(?string $titleRole): self
685.     {
686.         $this->titleRole = $titleRole;
688.         return $this;
689.     }
691.     public function getGuaranteeAmount(): ?float
692.     {
693.         return $this->guaranteeAmount;
694.     }
696.     public function setGuaranteeAmount(?float $guaranteeAmount): self
697.     {
698.         $this->guaranteeAmount = $guaranteeAmount;
700.         return $this;
701.     }
703.     public function getGuaranteeAmountUnitType(): ?UnitType
704.     {
705.         return $this->guaranteeAmountUnitType;
706.     }
708.     public function setGuaranteeAmountUnitType(?UnitType $guaranteeAmountUnitType): self
709.     {
710.         $this->guaranteeAmountUnitType = $guaranteeAmountUnitType;
712.         return $this;
713.     }
715.     public function getGuaranteePeriodUnitType(): ?UnitType
716.     {
717.         return $this->guaranteePeriodUnitType;
718.     }
720.     public function setGuaranteePeriodUnitType(?UnitType $guaranteePeriodUnitType): self
721.     {
722.         $this->guaranteePeriodUnitType = $guaranteePeriodUnitType;
724.         return $this;
725.     }
727.     /**
728.      * @return Collection<int, Commission>
729.      */
730.     public function getCommissions(): Collection
731.     {
732.         return $this->commissions;
733.     }
735.     public function addCommission(Commission $commission): static
736.     {
737.         if (!$this->commissions->contains($commission)) {
738.             $this->commissions->add($commission);
739.             $commission->setUser($this);
740.         }
742.         return $this;
743.     }
745.     public function removeCommission(Commission $commission): static
746.     {
747.         if ($this->commissions->removeElement($commission)) {
748.             // set the owning side to null (unless already changed)
749.             if ($commission->getUser() === $this) {
750.                 $commission->setUser(null);
751.             }
752.         }
754.         return $this;
755.     }
757.     /**
758.      * @return Collection<int, Credit>
759.      */
760.     public function getCredits(): Collection
761.     {
762.         return $this->credits;
763.     }
765.     public function addCredit(Credit $credit): static
766.     {
767.         if (!$this->credits->contains($credit)) {
768.             $this->credits->add($credit);
769.             $credit->setUser($this);
770.         }
772.         return $this;
773.     }
775.     public function removeCredit(Credit $credit): static
776.     {
777.         if ($this->credits->removeElement($credit)) {
778.             // set the owning side to null (unless already changed)
779.             if ($credit->getUser() === $this) {
780.                 $credit->setUser(null);
781.             }
782.         }
784.         return $this;
785.     }
787.     public function getMiddleName(): ?string
788.     {
789.         return $this->middleName;
790.     }
792.     public function setMiddleName(?string $middleName): static
793.     {
794.         $this->middleName = $middleName;
796.         return $this;
797.     }
799.     public function getEffectiveStartDate(): ?\DateTimeInterface
800.     {
801.         return $this->effectiveStartDate;
802.     }
804.     public function setEffectiveStartDate(?\DateTimeInterface $effectiveStartDate): static
805.     {
806.         $this->effectiveStartDate = $effectiveStartDate;
808.         return $this;
809.     }
811.     public function getDescription(): ?string
812.     {
813.         return $this->description;
814.     }
816.     public function setDescription(?string $description): static
817.     {
818.         $this->description = $description;
820.         return $this;
821.     }
823.     public function getHireDate(): ?\DateTimeInterface
824.     {
825.         return $this->hireDate;
826.     }
828.     public function setHireDate(?\DateTimeInterface $hireDate): static
829.     {
830.         $this->hireDate = $hireDate;
832.         return $this;
833.     }
835.     public function getTerminationDate(): ?\DateTimeInterface
836.     {
837.         return $this->terminationDate;
838.     }
840.     public function setTerminationDate(?\DateTimeInterface $terminationDate): static
841.     {
842.         $this->terminationDate = $terminationDate;
844.         return $this;
845.     }
847.     public function getPersonalTarget(): ?float
848.     {
849.         return $this->personalTarget;
850.     }
852.     public function setPersonalTarget(float $personalTarget): static
853.     {
854.         $this->personalTarget = $personalTarget;
856.         return $this;
857.     }
859.     public function getProratedPersonalTarget(): ?float
860.     {
861.         return $this->proratedPersonalTarget;
862.     }
864.     public function setProratedPersonalTarget(float $proratedPersonalTarget): static
865.     {
866.         $this->proratedPersonalTarget = $proratedPersonalTarget;
868.         return $this;
869.     }
871.     public function getPersonalCurrency(): ?Currency
872.     {
873.         return $this->personalCurrency;
874.     }
876.     public function setPersonalCurrency(Currency $personalCurrency): static
877.     {
878.         $this->personalCurrency = $personalCurrency;
880.         return $this;
881.     }
883.     public function getProratedSalary(): ?float
884.     {
885.         return $this->proratedSalary;
886.     }
888.     public function setProratedSalary(float $proratedSalary): static
889.     {
890.         $this->proratedSalary = $proratedSalary;
892.         return $this;
893.     }
895.     public function getPaymentCurrency(): ?Currency
896.     {
897.         return $this->paymentCurrency;
898.     }
900.     public function setPaymentCurrency(Currency $paymentCurrency): static
901.     {
902.         $this->paymentCurrency = $paymentCurrency;
904.         return $this;
905.     }
907.     public function getSalary(): ?FLOAT
908.     {
909.         return $this->salary;
910.     }
912.     public function setSalary(float $salary): static
913.     {
914.         $this->salary = $salary;
916.         return $this;
917.     }
919.     public function getSalaryCurrency(): ?Currency
920.     {
921.         return $this->salaryCurrency;
922.     }
924.     public function setSalaryCurrency(Currency $salaryCurrency): static
925.     {
926.         $this->salaryCurrency = $salaryCurrency;
928.         return $this;
929.     }
931.     public function getSalaryChangeDate(): ?\DateTimeInterface
932.     {
933.         return $this->salaryChangeDate;
934.     }
936.     public function setSalaryChangeDate(?\DateTimeInterface $salaryChangeDate): static
937.     {
938.         $this->salaryChangeDate = $salaryChangeDate;
940.         return $this;
941.     }
945.     /**
946.      * @return Collection<int, ManualPayment>
947.      */
948.     public function getManualPayments(): Collection
949.     {
950.         return $this->manualPayments;
951.     }
953.     public function addManualPayment(ManualPayment $manualPayment): static
954.     {
955.         if (!$this->manualPayments->contains($manualPayment)) {
956.             $this->manualPayments->add($manualPayment);
957.             $manualPayment->setUser($this);
958.         }
960.         return $this;
961.     }
963.     public function removeManualPayment(ManualPayment $manualPayment): static
964.     {
965.         if ($this->manualPayments->removeElement($manualPayment)) {
966.             // set the owning side to null (unless already changed)
967.             if ($manualPayment->getUser() === $this) {
968.                 $manualPayment->setUser(null);
969.             }
970.         }
972.         return $this;
973.     }
975.     public function getTitle(): ?Title
976.     {
977.         return $this->title;
978.     }
980.     public function setTitle(?Title $title): static
981.     {
982.         $this->title = $title;
984.         return $this;
985.     }
987.     public function getPositionTitleByDate($date)
988.     {
989.         if ($this->positions->isEmpty()) {
990.             return $this->getTitle();
991.         }
993.         $positions = $this->positions->toArray();
995.         usort($positions, function($a, $b) {
996.             return $b->getEffectiveStartDate() <=> $a->getEffectiveStartDate();
997.         });
999.         foreach ($positions as $position) {
1000.             if ($position->getEffectiveStartDate() <= $date) {
1001.                 return $position->getTitle();
1002.             }
1003.         }
1005.         return $this->getTitle();
1006.     }
1008.     /**
1009.      * @return Collection<int, OrderAssignment>
1010.      */
1011.     public function getOrderAssignments(): Collection
1012.     {
1013.         return $this->orderAssignments;
1014.     }
1016.     public function addOrderAssignment(OrderAssignment $orderAssignment): static
1017.     {
1018.         if (!$this->orderAssignments->contains($orderAssignment)) {
1019.             $this->orderAssignments->add($orderAssignment);
1020.             $orderAssignment->setUser($this);
1021.         }
1023.         return $this;
1024.     }
1026.     public function removeOrderAssignment(OrderAssignment $orderAssignment): static
1027.     {
1028.         if ($this->orderAssignments->removeElement($orderAssignment)) {
1029.             // set the owning side to null (unless already changed)
1030.             if ($orderAssignment->getUser() === $this) {
1031.                 $orderAssignment->setUser(null);
1032.             }
1033.         }
1035.         return $this;
1036.     }
1038.     /**
1039.      * @return Collection<int, EmployeeRepCode>
1040.      */
1041.     public function getEmployeeRepCodes(): Collection
1042.     {
1043.         return $this->employeeRepCodes;
1044.     }
1046.     public function addEmployeeRepCode(EmployeeRepCode $employeeRepCode): static
1047.     {
1048.         if (!$this->employeeRepCodes->contains($employeeRepCode)) {
1049.             $this->employeeRepCodes->add($employeeRepCode);
1050.             $employeeRepCode->setUser($this);
1051.         }
1053.         return $this;
1054.     }
1056.     public function removeEmployeeRepCode(EmployeeRepCode $employeeRepCode): static
1057.     {
1058.         if ($this->employeeRepCodes->removeElement($employeeRepCode)) {
1059.             // set the owning side to null (unless already changed)
1060.             if ($employeeRepCode->getUser() === $this) {
1061.                 $employeeRepCode->setUser(null);
1062.             }
1063.         }
1065.         return $this;
1066.     }
1068.     /**
1069.      * @return Collection<int, NamedRelationshipPosition>
1070.      */
1071.     public function getFromNamedRelationshipPositions(): Collection
1072.     {
1073.         return $this->fromNamedRelationshipPositions;
1074.     }
1076.     public function addFromNamedRelationshipPosition(NamedRelationshipPosition $fromNamedRelationshipPosition): static
1077.     {
1078.         if (!$this->fromNamedRelationshipPositions->contains($fromNamedRelationshipPosition)) {
1079.             $this->fromNamedRelationshipPositions->add($fromNamedRelationshipPosition);
1080.             $fromNamedRelationshipPosition->setFromUser($this);
1081.         }
1083.         return $this;
1084.     }
1086.     public function removeFromNamedRelationshipPosition(NamedRelationshipPosition $fromNamedRelationshipPosition): static
1087.     {
1088.         if ($this->fromNamedRelationshipPositions->removeElement($fromNamedRelationshipPosition)) {
1089.             // set the owning side to null (unless already changed)
1090.             if ($fromNamedRelationshipPosition->getFromUser() === $this) {
1091.                 $fromNamedRelationshipPosition->setFromUser(null);
1092.             }
1093.         }
1095.         return $this;
1096.     }
1098.     /**
1099.      * @return Collection<int, NamedRelationshipPosition>
1100.      */
1101.     public function getToNamedRelationshipPositions(): Collection
1102.     {
1103.         return $this->toNamedRelationshipPositions;
1104.     }
1106.     public function addToNamedRelationshipPosition(NamedRelationshipPosition $toNamedRelationshipPosition): static
1107.     {
1108.         if (!$this->toNamedRelationshipPositions->contains($toNamedRelationshipPosition)) {
1109.             $this->toNamedRelationshipPositions->add($toNamedRelationshipPosition);
1110.             $toNamedRelationshipPosition->setToUser($this);
1111.         }
1113.         return $this;
1114.     }
1116.     public function removeToNamedRelationshipPosition(NamedRelationshipPosition $toNamedRelationshipPosition): static
1117.     {
1118.         if ($this->toNamedRelationshipPositions->removeElement($toNamedRelationshipPosition)) {
1119.             // set the owning side to null (unless already changed)
1120.             if ($toNamedRelationshipPosition->getToUser() === $this) {
1121.                 $toNamedRelationshipPosition->setToUser(null);
1122.             }
1123.         }
1125.         return $this;
1126.     }
1128.     /**
1129.      * @return Collection<int, LookUpTable>
1130.      */
1131.     public function getLookUpTables(): Collection
1132.     {
1133.         return $this->lookUpTables;
1134.     }
1136.     public function addLookUpTable(LookUpTable $lookUpTable): static
1137.     {
1138.         if (!$this->lookUpTables->contains($lookUpTable)) {
1139.             $this->lookUpTables->add($lookUpTable);
1140.             $lookUpTable->setAssignedUser($this);
1141.         }
1143.         return $this;
1144.     }
1146.     public function removeLookUpTable(LookUpTable $lookUpTable): static
1147.     {
1148.         if ($this->lookUpTables->removeElement($lookUpTable)) {
1149.             // set the owning side to null (unless already changed)
1150.             if ($lookUpTable->getAssignedUser() === $this) {
1151.                 $lookUpTable->setAssignedUser(null);
1152.             }
1153.         }
1155.         return $this;
1156.     }
1158.     /**
1159.      * @return Collection<int, RateTableAssignment>
1160.      */
1161.     public function getRateTableAssignments(): Collection
1162.     {
1163.         return $this->rateTableAssignments;
1164.     }
1166.     public function addRateTableAssignment(RateTableAssignment $rateTableAssignment): static
1167.     {
1168.         if (!$this->rateTableAssignments->contains($rateTableAssignment)) {
1169.             $this->rateTableAssignments->add($rateTableAssignment);
1170.             $rateTableAssignment->setUser($this);
1171.         }
1173.         return $this;
1174.     }
1176.     public function removeRateTableAssignment(RateTableAssignment $rateTableAssignment): static
1177.     {
1178.         if ($this->rateTableAssignments->removeElement($rateTableAssignment)) {
1179.             // set the owning side to null (unless already changed)
1180.             if ($rateTableAssignment->getUser() === $this) {
1181.                 $rateTableAssignment->setUser(null);
1182.             }
1183.         }
1185.         return $this;
1186.     }
1188.     /**
1189.      * @return Collection<int, RuleCondition>
1190.      */
1191.     public function getRuleConditions(): Collection
1192.     {
1193.         return $this->ruleConditions;
1194.     }
1196.     public function addRuleCondition(RuleCondition $ruleCondition): static
1197.     {
1198.         if (!$this->ruleConditions->contains($ruleCondition)) {
1199.             $this->ruleConditions->add($ruleCondition);
1200.             $ruleCondition->setUser($this);
1201.         }
1203.         return $this;
1204.     }
1206.     public function removeRuleCondition(RuleCondition $ruleCondition): static
1207.     {
1208.         if ($this->ruleConditions->removeElement($ruleCondition)) {
1209.             // set the owning side to null (unless already changed)
1210.             if ($ruleCondition->getUser() === $this) {
1211.                 $ruleCondition->setUser(null);
1212.             }
1213.         }
1215.         return $this;
1216.     }
1218.     /**
1219.      * @return Collection<int, Hierarchy>
1220.      */
1221.     public function getHierarchies(): Collection
1222.     {
1223.         return $this->hierarchies;
1224.     }
1226.     public function addHierarchy(Hierarchy $hierarchy): static
1227.     {
1228.         if (!$this->hierarchies->contains($hierarchy)) {
1229.             $this->hierarchies->add($hierarchy);
1230.             $hierarchy->setUser($this);
1231.         }
1233.         return $this;
1234.     }
1236.     public function removeHierarchy(Hierarchy $hierarchy): static
1237.     {
1238.         if ($this->hierarchies->removeElement($hierarchy)) {
1239.             // set the owning side to null (unless already changed)
1240.             if ($hierarchy->getUser() === $this) {
1241.                 $hierarchy->setUser(null);
1242.             }
1243.         }
1245.         return $this;
1246.     }
1248.     /**
1249.      * @return Collection<int, Hierarchy>
1250.      */
1251.     public function getParentHierarchies(): Collection
1252.     {
1253.         return $this->parentHierarchies;
1254.     }
1256.     public function addParentHierarchy(Hierarchy $parentHierarchy): static
1257.     {
1258.         if (!$this->parentHierarchies->contains($parentHierarchy)) {
1259.             $this->parentHierarchies->add($parentHierarchy);
1260.             $parentHierarchy->setParentUser($this);
1261.         }
1263.         return $this;
1264.     }
1266.     public function removeParentHierarchy(Hierarchy $parentHierarchy): static
1267.     {
1268.         if ($this->parentHierarchies->removeElement($parentHierarchy)) {
1269.             // set the owning side to null (unless already changed)
1270.             if ($parentHierarchy->getParentUser() === $this) {
1271.                 $parentHierarchy->setParentUser(null);
1272.             }
1273.         }
1275.         return $this;
1276.     }
1279.     public function getInitials(): string
1280.     {
1281.         $firstInitial = '';
1282.         $lastInitial = '';
1284.         if($this->getFirstName()) {
1285.             $firstInitial = mb_substr($this->getFirstName(), 0, 1);
1286.         }
1288.         if($this->getLastName()) {
1289.             $lastInitial = mb_substr($this->getLastName(), 0, 1);
1290.         }
1291.         return  $firstInitial . $lastInitial;
1293.     }
1296.     public function isAdmin(): bool
1297.     {
1298.         return $this->hasRole(self::ROLE_SUPER_ADMIN) || $this->hasRole(self::ROLE_ADMIN);
1299.     }
1301.     public function getEarningCommissionsStartDate(): ?\DateTimeInterface
1302.     {
1303.         return $this->earningCommissionsStartDate;
1304.     }
1306.     public function setEarningCommissionsStartDate(?\DateTimeInterface $earningCommissionsStartDate): static
1307.     {
1308.         $this->earningCommissionsStartDate = $earningCommissionsStartDate;
1310.         return $this;
1311.     }
1313.     public function getEarningCommissionsPeriod(): ?int
1314.     {
1315.         return $this->earningCommissionsPeriod;
1316.     }
1318.     public function setEarningCommissionsPeriod(?int $earningCommissionsPeriod): static
1319.     {
1320.         $this->earningCommissionsPeriod = $earningCommissionsPeriod;
1322.         return $this;
1323.     }
1325.     public function getGuaranteeAlertSentAt(): ?\DateTimeInterface
1326.     {
1327.         return $this->guaranteeAlertSentAt;
1328.     }
1330.     public function setGuaranteeAlertSentAt(?\DateTimeInterface $guaranteeAlertSentAt): static
1331.     {
1332.         $this->guaranteeAlertSentAt = $guaranteeAlertSentAt;
1334.         return $this;
1335.     }
1337.     public function getRegion(): ?Region
1338.     {
1339.         return $this->region;
1340.     }
1342.     public function setRegion(?Region $region): static
1343.     {
1344.         $this->region = $region;
1346.         return $this;
1347.     }
1349.     /**
1350.      * @return Collection<int, UserLogin>
1351.      */
1352.     public function getUserLogins(): Collection
1353.     {
1354.         return $this->userLogins;
1355.     }
1357.     public function addUserLogin(UserLogin $userLogin): static
1358.     {
1359.         if (!$this->userLogins->contains($userLogin)) {
1360.             $this->userLogins->add($userLogin);
1361.             $userLogin->setUser($this);
1362.         }
1364.         return $this;
1365.     }
1367.     public function removeUserLogin(UserLogin $userLogin): static
1368.     {
1369.         if ($this->userLogins->removeElement($userLogin)) {
1370.             // set the owning side to null (unless already changed)
1371.             if ($userLogin->getUser() === $this) {
1372.                 $userLogin->setUser(null);
1373.             }
1374.         }
1376.         return $this;
1377.     }
1379.     /**
1380.      * @return Collection<int, AdMapping>
1381.      */
1382.     public function getAdMappings(): Collection
1383.     {
1384.         return $this->adMappings;
1385.     }
1387.     public function addAdMapping(AdMapping $adMapping): static
1388.     {
1389.         if (!$this->adMappings->contains($adMapping)) {
1390.             $this->adMappings->add($adMapping);
1391.             $adMapping->setUser($this);
1392.         }
1394.         return $this;
1395.     }
1397.     public function removeAdMapping(AdMapping $adMapping): static
1398.     {
1399.         if ($this->adMappings->removeElement($adMapping)) {
1400.             // set the owning side to null (unless already changed)
1401.             if ($adMapping->getUser() === $this) {
1402.                 $adMapping->setUser(null);
1403.             }
1404.         }
1406.         return $this;
1407.     }
1409.     /**
1410.      * @return Collection<int, UserRegion>
1411.      */
1412.     public function getUserRegions(): Collection
1413.     {
1414.         return $this->userRegions;
1415.     }
1417.     public function addUserRegion(UserRegion $userRegion): static
1418.     {
1419.         if (!$this->userRegions->contains($userRegion)) {
1420.             $this->userRegions->add($userRegion);
1421.             $userRegion->setUser($this);
1422.         }
1424.         return $this;
1425.     }
1427.     public function removeUserRegion(UserRegion $userRegion): static
1428.     {
1429.         if ($this->userRegions->removeElement($userRegion)) {
1430.             // set the owning side to null (unless already changed)
1431.             if ($userRegion->getUser() === $this) {
1432.                 $userRegion->setUser(null);
1433.             }
1434.         }
1436.         return $this;
1437.     }
1439.     /**
1440.      * @return Collection<int, CommissionShareRule>
1441.      */
1442.     public function getCommissionShareRulesTo(): Collection
1443.     {
1444.         return $this->commissionShareRulesTo;
1445.     }
1447.     public function addCommissionShareRulesTo(CommissionShareRule $commissionShareRulesTo): static
1448.     {
1449.         if (!$this->commissionShareRulesTo->contains($commissionShareRulesTo)) {
1450.             $this->commissionShareRulesTo->add($commissionShareRulesTo);
1451.             $commissionShareRulesTo->setToUser($this);
1452.         }
1454.         return $this;
1455.     }
1457.     public function removeCommissionShareRulesTo(CommissionShareRule $commissionShareRulesTo): static
1458.     {
1459.         if ($this->commissionShareRulesTo->removeElement($commissionShareRulesTo)) {
1460.             // set the owning side to null (unless already changed)
1461.             if ($commissionShareRulesTo->getToUser() === $this) {
1462.                 $commissionShareRulesTo->setToUser(null);
1463.             }
1464.         }
1466.         return $this;
1467.     }
1469.     public function getLeaveOfAbsenceStartDate(): ?\DateTimeInterface
1470.     {
1471.         return $this->leaveOfAbsenceStartDate;
1472.     }
1474.     public function setLeaveOfAbsenceStartDate(?\DateTimeInterface $leaveOfAbsenceStartDate): static
1475.     {
1476.         $this->leaveOfAbsenceStartDate = $leaveOfAbsenceStartDate;
1478.         return $this;
1479.     }
1481.     public function getLeaveOfAbsenceEndDate(): ?\DateTimeInterface
1482.     {
1483.         return $this->leaveOfAbsenceEndDate;
1484.     }
1486.     public function setLeaveOfAbsenceEndDate(?\DateTimeInterface $leaveOfAbsenceEndDate): static
1487.     {
1488.         $this->leaveOfAbsenceEndDate = $leaveOfAbsenceEndDate;
1490.         return $this;
1491.     }
1493.     public function isOnLeaveOfAbsence(?\DateTimeInterface $date = null): bool
1494.     {
1495.         if ($this->employeeStatus !== EmployeeStatus::LEAVE_OF_ABSENCE) {
1496.             return false;
1497.         }
1499.         if ($this->leaveOfAbsenceStartDate === null || $this->leaveOfAbsenceEndDate === null) {
1500.             return false;
1501.         }
1503.         $checkDate = $date ?? new \DateTime();
1505.         return $checkDate >= $this->leaveOfAbsenceStartDate && $checkDate <= $this->leaveOfAbsenceEndDate;
1506.     }
1507. }