src/Entity/CRM/LeaveRequest.php line 15

  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;
  14. #[ORM\Entity(repositoryClass: LeaveRequestRepository::class)]
  15. class LeaveRequest
  16. {
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     private ?int $id = null;
  22.     #[ORM\ManyToOne(inversedBy: 'leaveRequests')]
  23.     #[ORM\JoinColumn(nullable: true)]
  24.     private ?Consultant $consultant = null;
  26.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  27.     private ?\DateTimeInterface $startTime = null;
  29.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  30.     private ?\DateTimeInterface $endTime = null;
  32.     #[ORM\Column]
  33.     private ?bool $accepted = null;
  35.     #[ORM\ManyToOne(inversedBy: 'acceptedLeaveRequests')]
  36.     private ?Admin $acceptedBy = null;
  38.     #[ORM\Column]
  39.     private ?bool $rejected = null;
  41.     #[ORM\ManyToOne(inversedBy: 'rejectedLeaveRequests')]
  42.     private ?Admin $rejectedBy = null;
  44.     #[ORM\ManyToOne(inversedBy: 'LeaveRequest')]
  45.     private ?LeaveRequestType $leaveRequestType = null;
  47.     #[ORM\Column]
  48.     private ?bool $acceptedByHr = false;
  50.     #[ORM\ManyToOne]
  51.     private ?Admin $acceptedByHrBy = null;
  53.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  54.     private ?\DateTimeInterface $addedDate = null;
  56.     #[ORM\Column]
  57.     private ?int $leaveCategory = 1;
  59.     #[ORM\ManyToOne(inversedBy: 'leaveRequests')]
  60.     private ?Admin $admin = null;
  62.     #[ORM\OneToMany(mappedBy: 'leaveRequest', targetEntity: LeaveRequestAllocation::class, cascade: ['persist', 'remove'])]
  63.     private Collection $leaveRequestAllocations;
  65.     #[ORM\Column(length: 255, nullable: true)]
  66.     private ?string $workTimeSettlement = null;
  68.     public function __construct()
  69.     {
  70.         $this->consultant = null;
  71.         $this->admin = null;
  72.         $this->accepted = false;
  73.         $this->rejected = false;
  74.         $this->acceptedByHr = false;
  75.         $this->addedDate = new DateTime();
  76.         $this->leaveRequestAllocations = new ArrayCollection();
  77.         $this->workTimeSettlement = NULL;
  78.     }
  80.     public function getId(): ?int
  81.     {
  82.         return $this->id;
  83.     }
  85.     public function getConsultant(): ?Consultant
  86.     {
  87.         return $this->consultant;
  88.     }
  90.     public function setConsultant(?Consultant $consultant): static
  91.     {
  92.         $this->consultant = $consultant;
  94.         return $this;
  95.     }
  97.     public function getStartTime(): ?\DateTimeInterface
  98.     {
  99.         return $this->startTime;
  100.     }
  102.     public function setStartTime(\DateTimeInterface $startTime): static
  103.     {
  104.         $this->startTime = $startTime;
  106.         return $this;
  107.     }
  109.     public function getEndTime(): ?\DateTimeInterface
  110.     {
  111.         return $this->endTime;
  112.     }
  114.     public function setEndTime(\DateTimeInterface $endTime): static
  115.     {
  116.         $this->endTime = $endTime;
  118.         return $this;
  119.     }
  121.     public function isAccepted(): ?bool
  122.     {
  123.         return $this->accepted;
  124.     }
  126.     public function setAccepted(bool $accepted): static
  127.     {
  128.         $this->accepted = $accepted;
  130.         return $this;
  131.     }
  133.     public function getAcceptedBy(): ?Admin
  134.     {
  135.         return $this->acceptedBy;
  136.     }
  138.     public function setAcceptedBy(?Admin $acceptedBy): static
  139.     {
  140.         $this->acceptedBy = $acceptedBy;
  142.         return $this;
  143.     }
  145.     public function isRejected(): ?bool
  146.     {
  147.         return $this->rejected;
  148.     }
  150.     public function setRejected(bool $rejected): static
  151.     {
  152.         $this->rejected = $rejected;
  154.         return $this;
  155.     }
  157.     public function getRejectedBy(): ?Admin
  158.     {
  159.         return $this->rejectedBy;
  160.     }
  162.     public function setRejectedBy(?Admin $rejectedBy): static
  163.     {
  164.         $this->rejectedBy = $rejectedBy;
  166.         return $this;
  167.     }
  169.     public function getLeaveRequestType(): ?LeaveRequestType
  170.     {
  171.         return $this->leaveRequestType;
  172.     }
  174.     public function setLeaveRequestType(?LeaveRequestType $leaveRequestType): static
  175.     {
  176.         $this->leaveRequestType = $leaveRequestType;
  178.         return $this;
  179.     }
  181.     public function getDuration(): string
  182.     {
  183.         //method doesn't count public holidays, suitable for daily(leaveCategory == 2) leave requests
  184.         if (!$this->getStartTime() || !$this->getEndTime()) {
  185.             return 'N/A';
  186.         }
  188.         $category = $this->getLeaveCategory();
  190.         // Kategoria 1: Dzienne — zwracaj liczbę dni roboczych (bez weekendów), bez jednostki
  191.         if ($category === 1) {
  192.             $startTime = clone $this->getStartTime();
  193.             $endTime = clone $this->getEndTime();
  195.             // Ustaw tylko datę, aby liczyć pełne dni
  196.             $currentDay = (clone $startTime)->setTime(0, 0, 0);
  197.             $lastDay = (clone $endTime)->setTime(0, 0, 0);
  199.             // Jeśli zakres jest odwrócony
  200.             if ($lastDay < $currentDay) {
  201.                 return '0';
  202.             }
  204.             $workingDays = 0;
  205.             while ($currentDay <= $lastDay) {
  206.                 $dayOfWeek = (int)$currentDay->format('N'); // 1=pon, ..., 7=niedz
  207.                 if ($dayOfWeek !== 6 && $dayOfWeek !== 7) {
  208.                     $workingDays++;
  209.                 }
  210.                 $currentDay = (clone $currentDay)->modify('+1 day');
  211.             }
  213.             return (string)$workingDays.' dni';
  214.         }
  216.         // Kategoria 2: Godzinowe — zwracaj różnicę czasu jako "Xh Ym"
  217.         if ($category === 2) {
  218.             $start = $this->getStartTime();
  219.             $end = $this->getEndTime();
  221.             if ($end < $start) {
  222.                 return '0 godz.';
  223.             }
  225.             $diffSeconds = $end->getTimestamp() - $start->getTimestamp();
  226.             $totalMinutes = (int)floor($diffSeconds / 60);
  227.             $hours = intdiv($totalMinutes, 60);
  228.             $minutes = $totalMinutes % 60;
  230.             if ($hours > 0 && $minutes > 0) {
  231.                 return sprintf('%d godz. %dm', $hours, $minutes);
  232.             }
  233.             if ($hours > 0) {
  234.                 return sprintf('%d godz.', $hours);
  235.             }
  236.             return sprintf('%d godz.', $minutes);
  237.         }
  239.         // Fallback: licz dni robocze jak w kategorii dziennej
  240.         $startTime = clone $this->getStartTime();
  241.         $endTime = clone $this->getEndTime();
  243.         $currentDay = (clone $startTime)->setTime(0, 0, 0);
  244.         $lastDay = (clone $endTime)->setTime(0, 0, 0);
  246.         if ($lastDay < $currentDay) {
  247.             return '0';
  248.         }
  250.         $workingDays = 0;
  251.         while ($currentDay <= $lastDay) {
  252.             $dayOfWeek = (int)$currentDay->format('N');
  253.             if ($dayOfWeek !== 6 && $dayOfWeek !== 7) {
  254.                 $workingDays++;
  255.             }
  256.             $currentDay = (clone $currentDay)->modify('+1 day');
  257.         }
  259.         return (string)$workingDays.' dni';
  260.     }
  262.     public function getAcceptedOrRejected():string{
  263.         if($this->isRejected()){
  264.             return 'Odrzucone';
  265.         }
  266.         if($this->isAccepted()){
  267.             return 'Zaakceptowany';
  268.         }
  269.         return 'w trakcie';
  270.     }
  272.     public function isAcceptedByHr(): ?bool
  273.     {
  274.         return $this->acceptedByHr;
  275.     }
  276.     public function getAcceptedByHr(): bool
  277.     {
  278.         return $this->acceptedByHr;
  279.     }
  281.     public function setAcceptedByHr(bool $acceptedByHr): static
  282.     {
  283.         $this->acceptedByHr = $acceptedByHr;
  285.         return $this;
  286.     }
  288.     public function getAcceptedByHrBy(): ?Admin
  289.     {
  290.         return $this->acceptedByHrBy;
  291.     }
  293.     public function setAcceptedByHrBy(?Admin $acceptedByHrBy): static
  294.     {
  295.         $this->acceptedByHrBy = $acceptedByHrBy;
  297.         return $this;
  298.     }
  300.     public function getAddedDate(): ?\DateTimeInterface
  301.     {
  302.         return $this->addedDate;
  303.     }
  305.     public function setAddedDate(?\DateTimeInterface $addedDate): static
  306.     {
  307.         $this->addedDate = $addedDate;
  309.         return $this;
  310.     }
  312.     public function getLeaveCategory(): ?int
  313.     {
  314.         return $this->leaveCategory;
  315.     }
  317.     public function setLeaveCategory(int $leaveCategory): static
  318.     {
  319.         $this->leaveCategory = $leaveCategory;
  321.         return $this;
  322.     }
  324.     public function getAdmin(): ?Admin
  325.     {
  326.         return $this->admin;
  327.     }
  329.     public function setAdmin(?Admin $admin): static
  330.     {
  331.         $this->admin = $admin;
  333.         return $this;
  334.     }
  336.     /**
  337.      * @return Collection<int, LeaveRequestAllocation>
  338.      */
  339.     public function getLeaveRequestAllocations(): Collection
  340.     {
  341.         return $this->leaveRequestAllocations;
  342.     }
  344.     public function getLeaveRequestPlannedMinutes(): int
  345.     {
  346.         return (int) (($this->endTime->getTimestamp() - $this->startTime->getTimestamp()) / 60);
  347.     }
  349.     public function getLeaveRequestUsedMinutes()
  350.     {
  351.         $sum = 0;
  352.         foreach ($this->leaveRequestAllocations as $allocation) {
  353.             $sum += $allocation->getMinutesUsed();
  354.         }
  356.         return $sum;
  357.     }
  359.     public function getLeaveRequestRemainingMinutes(): int
  360.     {
  361.         return $this->getLeaveRequestPlannedMinutes() - $this->getLeaveRequestUsedMinutes();
  362.     }
  364.     public function addLeaveRequestAllocation(LeaveRequestAllocation $leaveRequestAllocation): static
  365.     {
  366.         if (!$this->leaveRequestAllocations->contains($leaveRequestAllocation)) {
  367.             $this->leaveRequestAllocations->add($leaveRequestAllocation);
  368.             $leaveRequestAllocation->setLeaveRequest($this);
  369.         }
  371.         return $this;
  372.     }
  374.     public function removeLeaveRequestAllocation(LeaveRequestAllocation $leaveRequestAllocation): static
  375.     {
  376.         if ($this->leaveRequestAllocations->removeElement($leaveRequestAllocation)) {
  377.             // set the owning side to null (unless already changed)
  378.             if ($leaveRequestAllocation->getLeaveRequest() === $this) {
  379.                 $leaveRequestAllocation->setLeaveRequest(null);
  380.             }
  381.         }
  383.         return $this;
  384.     }
  386.     public function getWorkTimeSettlement(): ?string
  387.     {
  388.         return $this->workTimeSettlement;
  389.     }
  391.     public function setWorkTimeSettlement(?string $workTimeSettlement): static
  392.     {
  393.         $this->workTimeSettlement = $workTimeSettlement;
  395.         return $this;
  396.     }
  398.     #[Assert\Callback]
  399.     public function validateMinDailyDuration(ExecutionContextInterface $context): void
  400.     {
  401.         $start = $this->getStartTime();
  402.         $end   = $this->getEndTime();
  404.         if (!$start || !$end) {
  405.             return;
  406.         }
  408.         $user = $this->getAdmin() ?? $this->getConsultant();
  409.         $nominalHours = $user?->getNominalWorkTime()?->getEmploymentFactor() ?? 8;
  411.         if (($end->getTimestamp() - $start->getTimestamp()) < ($nominalHours * 3600)) {
  412.             $context->buildViolation('Wniosek urlopowy musi obejmować co najmniej {{ h }} godzin, aby pokryć nominalny czas pracy.')
  413.                 ->setParameter('{{ h }}', (string)$nominalHours)
  414.                 ->atPath('endTime')
  415.                 ->addViolation();
  416.         }
  417.     }
  418. }