src/Entity/CRM/LeaveRequest.php line 19

  1. <?php
  3. namespace App\Entity\CRM;
  5. use App\Repository\LeaveRequestRepository;
  6. use DateTime;
  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\Component\Validator\Context\ExecutionContextInterface;
  12. use Symfony\Component\Validator\Constraints as Assert;
  13. use App\Validator\Constraints as AppAssert;
  15. #[AppAssert\NoLeaveRequestIfWorked]
  16. #[AppAssert\NoOverlappingLeaveRequest]
  17. #[AppAssert\EnoughLeaveBalance]
  18. #[ORM\Entity(repositoryClass: LeaveRequestRepository::class)]
  19. class LeaveRequest
  20. {
  21.     #[ORM\Id]
  22.     #[ORM\GeneratedValue]
  23.     #[ORM\Column]
  24.     private ?int $id = null;
  26.     #[ORM\ManyToOne(inversedBy: 'leaveRequests')]
  27.     #[ORM\JoinColumn(nullable: true)]
  28.     private ?Consultant $consultant = null;
  30.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  31.     private ?\DateTimeInterface $startTime = null;
  33.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  34.     private ?\DateTimeInterface $endTime = null;
  36.     #[ORM\Column]
  37.     private ?bool $accepted = null;
  39.     #[ORM\ManyToOne(inversedBy: 'acceptedLeaveRequests')]
  40.     private ?Admin $acceptedBy = null;
  42.     #[ORM\Column]
  43.     private ?bool $rejected = null;
  45.     #[ORM\ManyToOne(inversedBy: 'rejectedLeaveRequests')]
  46.     private ?Admin $rejectedBy = null;
  48.     #[ORM\ManyToOne(inversedBy: 'LeaveRequest')]
  49.     private ?LeaveRequestType $leaveRequestType = null;
  51.     #[ORM\Column]
  52.     private ?bool $acceptedByHr = false;
  54.     #[ORM\ManyToOne]
  55.     private ?Admin $acceptedByHrBy = null;
  57.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  58.     private ?\DateTimeInterface $addedDate = null;
  60.     #[ORM\Column]
  61.     private ?int $leaveCategory = 1;
  63.     #[ORM\ManyToOne(inversedBy: 'leaveRequests')]
  64.     private ?Admin $admin = null;
  66.     #[ORM\OneToMany(mappedBy: 'leaveRequest', targetEntity: LeaveRequestAllocation::class, cascade: ['persist', 'remove'])]
  67.     private Collection $leaveRequestAllocations;
  69.     #[ORM\Column(length: 255, nullable: true)]
  70.     private ?string $workTimeSettlement = null;
  72.     #[ORM\Column]
  73.     private ?bool $forHourlySettlement = null;
  75.     #[ORM\Column(nullable: true)]
  76.     private ?int $employmentFactor = null;
  78.     public function __construct()
  79.     {
  80.         $this->consultant = null;
  81.         $this->admin = null;
  82.         $this->accepted = false;
  83.         $this->rejected = false;
  84.         $this->acceptedByHr = false;
  85.         $this->addedDate = new DateTime();
  86.         $this->leaveRequestAllocations = new ArrayCollection();
  87.         $this->workTimeSettlement = NULL;
  88.     }
  90.     public function getId(): ?int
  91.     {
  92.         return $this->id;
  93.     }
  95.     public function getConsultant(): ?Consultant
  96.     {
  97.         return $this->consultant;
  98.     }
  100.     public function setConsultant(?Consultant $consultant): static
  101.     {
  102.         $this->consultant = $consultant;
  104.         return $this;
  105.     }
  107.     public function getStartTime(): ?\DateTimeInterface
  108.     {
  109.         return $this->startTime;
  110.     }
  112.     public function setStartTime(\DateTimeInterface $startTime): static
  113.     {
  114.         $this->startTime = $startTime;
  116.         return $this;
  117.     }
  119.     public function getEndTime(): ?\DateTimeInterface
  120.     {
  121.         return $this->endTime;
  122.     }
  124.     public function setEndTime(\DateTimeInterface $endTime): static
  125.     {
  126.         $this->endTime = $endTime;
  128.         return $this;
  129.     }
  131.     public function isAccepted(): ?bool
  132.     {
  133.         return $this->accepted;
  134.     }
  136.     public function setAccepted(bool $accepted): static
  137.     {
  138.         $this->accepted = $accepted;
  140.         return $this;
  141.     }
  143.     public function getAcceptedBy(): ?Admin
  144.     {
  145.         return $this->acceptedBy;
  146.     }
  148.     public function setAcceptedBy(?Admin $acceptedBy): static
  149.     {
  150.         $this->acceptedBy = $acceptedBy;
  152.         return $this;
  153.     }
  155.     public function isRejected(): ?bool
  156.     {
  157.         return $this->rejected;
  158.     }
  160.     public function setRejected(bool $rejected): static
  161.     {
  162.         $this->rejected = $rejected;
  164.         return $this;
  165.     }
  167.     public function getRejectedBy(): ?Admin
  168.     {
  169.         return $this->rejectedBy;
  170.     }
  172.     public function setRejectedBy(?Admin $rejectedBy): static
  173.     {
  174.         $this->rejectedBy = $rejectedBy;
  176.         return $this;
  177.     }
  179.     public function getLeaveRequestType(): ?LeaveRequestType
  180.     {
  181.         return $this->leaveRequestType;
  182.     }
  184.     public function setLeaveRequestType(LeaveRequestType $leaveRequestType): void
  185.     {
  186.         $this->leaveRequestType = $leaveRequestType;
  187.     }
  189.     public function getDuration(): string
  190.     {
  191.         //method doesn't count public holidays, suitable for daily(leaveCategory == 2) leave requests
  192.         if (!$this->getStartTime() || !$this->getEndTime()) {
  193.             return 'N/A';
  194.         }
  196.         $category = $this->getLeaveCategory();
  197.         $isChildCare = $this->leaveRequestType ? $this->leaveRequestType->isChildCare() : false;
  198.         // Kategoria 1: Dzienne — zwracaj liczbę dni roboczych (bez weekendów), bez jednostki
  199.         if ($category === 1 && !$isChildCare) {
  200.             $startTime = clone $this->getStartTime();
  201.             $endTime = clone $this->getEndTime();
  203.             // Ustaw tylko datę, aby liczyć pełne dni
  204.             $currentDay = (clone $startTime)->setTime(0, 0, 0);
  205.             $lastDay = (clone $endTime)->setTime(0, 0, 0);
  207.             // Jeśli zakres jest odwrócony
  208.             if ($lastDay < $currentDay) {
  209.                 return '0';
  210.             }
  212.             $workingDays = 0;
  213.             while ($currentDay <= $lastDay) {
  214.                 $dayOfWeek = (int)$currentDay->format('N'); // 1=pon, ..., 7=niedz
  215.                 if ($dayOfWeek !== 6 && $dayOfWeek !== 7) {
  216.                     $workingDays++;
  217.                 }
  218.                 $currentDay = (clone $currentDay)->modify('+1 day');
  219.             }
  221.             return (string)$workingDays.' dni';
  222.         }
  224.         // Kategoria 2: Godzinowe — zwracaj różnicę czasu jako "Xh Ym"
  225.         if ($category === 2 || $isChildCare) {
  226.             $start = $this->getStartTime();
  227.             $end = $this->getEndTime();
  229.             if ($end < $start) {
  230.                 return '0 godz.';
  231.             }
  233.             $diffSeconds = $end->getTimestamp() - $start->getTimestamp();
  234.             $totalMinutes = (int)floor($diffSeconds / 60);
  235.             $hours = intdiv($totalMinutes, 60);
  236.             $minutes = $totalMinutes % 60;
  238.             if ($hours > 0 && $minutes > 0) {
  239.                 return sprintf('%d godz. %dm', $hours, $minutes);
  240.             }
  241.             if ($hours > 0) {
  242.                 return sprintf('%d godz.', $hours);
  243.             }
  244.             return sprintf('%d godz.', $minutes);
  245.         }
  247.         // Fallback: licz dni robocze jak w kategorii dziennej
  248.         $startTime = clone $this->getStartTime();
  249.         $endTime = clone $this->getEndTime();
  251.         $currentDay = (clone $startTime)->setTime(0, 0, 0);
  252.         $lastDay = (clone $endTime)->setTime(0, 0, 0);
  254.         if ($lastDay < $currentDay) {
  255.             return '0';
  256.         }
  258.         $workingDays = 0;
  259.         while ($currentDay <= $lastDay) {
  260.             $dayOfWeek = (int)$currentDay->format('N');
  261.             if ($dayOfWeek !== 6 && $dayOfWeek !== 7) {
  262.                 $workingDays++;
  263.             }
  264.             $currentDay = (clone $currentDay)->modify('+1 day');
  265.         }
  267.         return (string)$workingDays.' dni';
  268.     }
  270.     public function getAcceptedOrRejected():string{
  271.         if($this->isRejected()){
  272.             return 'Odrzucone';
  273.         }
  274.         if($this->isAccepted()){
  275.             return 'Zaakceptowany';
  276.         }
  277.         return 'w trakcie';
  278.     }
  280.     public function isAcceptedByHr(): ?bool
  281.     {
  282.         return $this->acceptedByHr;
  283.     }
  284.     public function getAcceptedByHr(): bool
  285.     {
  286.         return $this->acceptedByHr;
  287.     }
  289.     public function setAcceptedByHr(bool $acceptedByHr): static
  290.     {
  291.         $this->acceptedByHr = $acceptedByHr;
  293.         return $this;
  294.     }
  296.     public function getAcceptedByHrBy(): ?Admin
  297.     {
  298.         return $this->acceptedByHrBy;
  299.     }
  301.     public function setAcceptedByHrBy(?Admin $acceptedByHrBy): static
  302.     {
  303.         $this->acceptedByHrBy = $acceptedByHrBy;
  305.         return $this;
  306.     }
  308.     public function getAddedDate(): ?\DateTimeInterface
  309.     {
  310.         return $this->addedDate;
  311.     }
  313.     public function setAddedDate(?\DateTimeInterface $addedDate): static
  314.     {
  315.         $this->addedDate = $addedDate;
  317.         return $this;
  318.     }
  320.     public function getLeaveCategory(): ?int
  321.     {
  322.         return $this->leaveCategory;
  323.     }
  325.     public function setLeaveCategory(int $leaveCategory): static
  326.     {
  327.         $this->leaveCategory = $leaveCategory;
  329.         return $this;
  330.     }
  332.     public function getAdmin(): ?Admin
  333.     {
  334.         return $this->admin;
  335.     }
  337.     public function setAdmin(?Admin $admin): static
  338.     {
  339.         $this->admin = $admin;
  341.         return $this;
  342.     }
  344.     /**
  345.      * @return Collection<int, LeaveRequestAllocation>
  346.      */
  347.     public function getLeaveRequestAllocations(): Collection
  348.     {
  349.         return $this->leaveRequestAllocations;
  350.     }
  352.     public function getLeaveRequestPlannedMinutes(): int
  353.     {
  354.         return (int) (($this->endTime->getTimestamp() - $this->startTime->getTimestamp()) / 60);
  355.     }
  357.     public function getLeaveRequestUsedMinutes()
  358.     {
  359.         $sum = 0;
  360.         foreach ($this->leaveRequestAllocations as $allocation) {
  361.             $sum += $allocation->getMinutesUsed();
  362.         }
  364.         return $sum;
  365.     }
  367.     public function getLeaveRequestRemainingMinutes(): int
  368.     {
  369.         return $this->getLeaveRequestPlannedMinutes() - $this->getLeaveRequestUsedMinutes();
  370.     }
  372.     public function addLeaveRequestAllocation(LeaveRequestAllocation $leaveRequestAllocation): static
  373.     {
  374.         if (!$this->leaveRequestAllocations->contains($leaveRequestAllocation)) {
  375.             $this->leaveRequestAllocations->add($leaveRequestAllocation);
  376.             $leaveRequestAllocation->setLeaveRequest($this);
  377.         }
  379.         return $this;
  380.     }
  382.     public function removeLeaveRequestAllocation(LeaveRequestAllocation $leaveRequestAllocation): static
  383.     {
  384.         if ($this->leaveRequestAllocations->removeElement($leaveRequestAllocation)) {
  385.             // set the owning side to null (unless already changed)
  386.             if ($leaveRequestAllocation->getLeaveRequest() === $this) {
  387.                 $leaveRequestAllocation->setLeaveRequest(null);
  388.             }
  389.         }
  391.         return $this;
  392.     }
  394.     public function getWorkTimeSettlement(): ?string
  395.     {
  396.         return $this->workTimeSettlement;
  397.     }
  399.     public function setWorkTimeSettlement(?string $workTimeSettlement): static
  400.     {
  401.         $this->workTimeSettlement = $workTimeSettlement;
  403.         return $this;
  404.     }
  406.     #[Assert\Callback]
  407.     public function validateSingleLeaveRequestUser(ExecutionContextInterface $context): void
  408.     {
  409.         $hasAdmin = $this->getAdmin() !== null;
  410.         $hasConsultant = $this->getConsultant() !== null;
  412.         if ($hasAdmin !== $hasConsultant) {
  413.             return;
  414.         }
  416.         $message = $hasAdmin
  417.             ? 'Wybierz tylko jedno pole: Admin albo Consultant.'
  418.             : 'Wybierz Admina albo Consultanta.';
  420.         $context->buildViolation($message)
  421.             ->atPath('admin')
  422.             ->addViolation();
  423.         $context->buildViolation($message)
  424.             ->atPath('consultant')
  425.             ->addViolation();
  426.     }
  428.     #[Assert\Callback]
  429.     public function validateMinDailyDuration(ExecutionContextInterface $context): void
  430.     {
  431.         $start = $this->getStartTime();
  432.         $end   = $this->getEndTime();
  433.         $leaveRequestType = $this->getLeaveRequestType();
  434.         $isChildCare = $leaveRequestType->isChildCare();
  436.         if (!$start || !$end) {
  437.             return;
  438.         }
  440.         $user = $this->getAdmin() ?? $this->getConsultant();
  441.         $nominalHours = $this->resolveEmploymentFactorForValidation($user);
  443.         if (($end->getTimestamp() - $start->getTimestamp()) < ($nominalHours * 3600) && !$isChildCare) {
  444.             $context->buildViolation('Wniosek urlopowy musi obejmować co najmniej {{ h }} godzin, aby pokryć nominalny czas pracy.')
  445.                 ->setParameter('{{ h }}', (string)$nominalHours)
  446.                 ->atPath('endTime')
  447.                 ->addViolation();
  448.         }
  449.     }
  451.     private function resolveEmploymentFactorForValidation(mixed $user): int
  452.     {
  453.         if ($user instanceof Admin) {
  454.             return $this->resolveEmploymentFactor(
  455.                 $user->isDisability(),
  456.                 $user->getAdminContractType(),
  457.                 $user->getNominalWorkTime()?->getEmploymentFactor()
  458.             );
  459.         }
  461.         if ($user instanceof Consultant) {
  462.             return $this->resolveEmploymentFactor(
  463.                 $user->isDisability(),
  464.                 $user->getConsultantContractType(),
  465.                 $user->getNominalWorkTime()?->getEmploymentFactor()
  466.             );
  467.         }
  469.         return 8;
  470.     }
  472.     private function resolveEmploymentFactor(bool $hasDisability, ?EmploymentContractType $contractType, ?int $nominalEmploymentFactor): int
  473.     {
  474.         if ($hasDisability && $this->isFullTimeContract($contractType)) {
  475.             return 8;
  476.         }
  478.         return $nominalEmploymentFactor ?? 8;
  479.     }
  481.     private function isFullTimeContract(?EmploymentContractType $contractType): bool
  482.     {
  483.         return $contractType !== null && abs(($contractType->getMultiplier() ?? 0.0) - 1.0) < 0.0001;
  484.     }
  486.     public function isForHourlySettlement(): ?bool
  487.     {
  488.         return $this->forHourlySettlement;
  489.     }
  491.     public function setForHourlySettlement(bool $forHourlySettlement): static
  492.     {
  493.         $this->forHourlySettlement = $forHourlySettlement;
  495.         return $this;
  496.     }
  498.     public function getEmploymentFactor(): ?int
  499.     {
  500.         return $this->employmentFactor;
  501.     }
  503.     public function setEmploymentFactor(?int $employmentFactor): void
  504.     {
  505.         $this->employmentFactor = $employmentFactor;
  506.     }
  507. }