src/Entity/TimeControl/TimeEntry.php line 113

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace App\Entity\TimeControl;
  7. use ApiPlatform\Core\Annotation\{ApiFilter, ApiProperty, ApiResource};
  8. use ApiPlatform\Core\Bridge\Doctrine\Orm\{Filter\DateFilter, Filter\ExistsFilter, Filter\OrderFilter, Filter\SearchFilter};
  9. use App\Dto\{DeveloperTimeOutput, TimeEntryApproveInput, TimeEntryBreakInput, TimeEntryFixInput, TimeEntryFixOutput};
  10. use App\Entity\{Profile, Project\Project, User};
  11. use App\Interfaces\UuidKeyInterface;
  12. use App\Repository\TimeEntryRepository;
  13. use App\Service\DateTimeHelper;
  14. use App\Traits\TimeEntryTrait;
  15. use App\Traits\TimestampableEntity;
  16. use App\Traits\UuidEntityTrait;
  17. use App\Validator\{TimeEntryBlocked as AssertBlocked, TimeEntryLength as AssertTimeEntryLength};
  18. use Doctrine\ORM\Mapping as ORM;
  19. use Symfony\Component\Serializer\Annotation\Groups;
  20. use Symfony\Component\Validator\{Constraints as Assert, Context\ExecutionContextInterface};
  22. /**
  23.  * @see \App\EventSubscriber\TimeEntryEventSubscriber
  24.  */
  25. #[ApiResource(
  26.     collectionOperations: [
  27.         'get',
  28.         'post' => [
  29.             'security_post_denormalize' => "is_granted('ENTRY_CREATE', object)",
  30.             'security_message' => 'Only developer himself or Project Manager can create Time entries',
  31.             'validation_groups' => [TimeEntry::VG_CREATE],
  32.         ],
  33.         'developers' => [
  34.             'method' => 'GET',
  35.             'path' => 'time-entries/developers',
  36.             'openapi_context' => ['summary' => 'Get time for developers'],
  37.             'output' => DeveloperTimeOutput::class,
  38.         ],
  39.         'open' => [
  40.             'method' => 'POST',
  41.             'security_post_denormalize' => "is_granted('ENTRY_OPEN', object)",
  42.             'security_message' => 'Unable to open time entry for another user',
  43.             'path' => 'time-entries/open',
  44.             'openapi_context' => ['summary' => 'Open Time entry'],
  45.             'validation_groups' => [TimeEntry::VG_OPEN],
  46.         ],
  47.     ],
  48.     itemOperations: [
  49.         'get',
  50.         'put' => ['security' => "is_granted('ENTRY_MODIFY', object)"],
  51.         'delete' => [
  52.             'security' => "is_granted('ENTRY_DELETE', object)",
  53.             'security_message' => 'No access to Time Entry delete, or TE is Blocked',
  54.         ],
  55.         'patch' => [
  56.             'security' => "is_granted('ENTRY_MODIFY', object)",
  57.             'security_message' => 'No access to Time Entry modification',
  58.         ],
  59.         TimeEntry::ITEM_CLOSE => [
  60.             'method' => 'PATCH',
  61.             'path' => 'time-entries/{id}/close',
  62.             'security' => "is_granted('ENTRY_MODIFY', object)",
  63.             'openapi_context' => ['summary' => 'Closes current Time entry'],
  64.             'validation_groups' => [TimeEntry::VG_OPEN],
  65.         ],
  66.         TimeEntry::ITEM_BREAK => [
  67.             'method' => 'PATCH',
  68.             'path' => 'time-entries/{id}/break',
  69.             'security' => "is_granted('ENTRY_MODIFY', object)",
  70.             'input' => TimeEntryBreakInput::class,
  71.             'openapi_context' => ['summary' => 'Break Time entry'],
  72.         ],
  73.         TimeEntry::ITEM_APPROVED => [
  74.             'method' => 'PATCH',
  75.             'path' => 'time-entries/{id}/approved',
  76.             'security' => "is_granted('ENTRY_APPROVED', object)",
  77.             'input' => TimeEntryApproveInput::class,
  78.             'openapi_context' => ['summary' => 'Approved flag for TimeEntry is set by project manager or higher'],
  79.         ],
  80.         TimeEntry::PATCH_TE_OPERATION => [
  81.             'method' => 'PATCH',
  82.             'path' => 'time-entries/{id}/fix',
  83.             'input' => TimeEntryFixInput::class,
  84.             'output' => TimeEntryFixOutput::class,
  85.             'security' => "is_granted('ROLE_USER_FIXER')",
  86.             'openapi_context' => ['summary' => 'Set fix $ approved for time-entries'],
  87.         ],
  88.     ],
  89.     attributes: ['order' => ['start' => 'ASC']],
  90. )]
  91. #[ApiFilter(DateFilter::class, properties: [
  92.     'start' => DateFilter::EXCLUDE_NULL,
  93.     'end' => DateFilter::INCLUDE_NULL_BEFORE,
  94. ])]
  95. #[ApiFilter(SearchFilter::class, properties: [
  96.     'user.slug' => 'exact',
  97.     'project.slug' => 'exact',
  98. ])]
  99. #[ApiFilter(ExistsFilter::class, properties: ['end'])]
  100. #[ApiFilter(OrderFilter::class, properties: [
  101.     'start' => 'ASC',
  102.     'end' => 'ASC',
  103.     'user.slug' => 'ASC',
  104.     'project.slug' => 'ASC',
  105. ])]
  106. #[AssertBlocked()]
  107. #[AssertTimeEntryLength(minLength: AssertTimeEntryLength::MIN_TIME_LENGTH, maxlength: AssertTimeEntryLength::MAX_TIME_LENGTH)]
  108. #[ORM\Entity(repositoryClass: TimeEntryRepository::class)]
  109. #[ORM\Table]
  110. #[ORM\Index(name: 'idx_time_entry_timer_start', columns: ['timer_start'])]
  111. #[ORM\Index(name: 'idx_time_entry_timer_end', columns: ['timer_end'])]
  112. #[ORM\Index(name: 'idx_time_entry_is_fixed', columns: ['is_fixed'])]
  113. class TimeEntry implements UuidKeyInterface, \Stringable
  114. {
  115.     use UuidEntityTrait;
  116.     use TimestampableEntity;
  117.     use TimeEntryTrait;
  119.     public const ITEM_CLOSE = 'close';
  120.     public const ITEM_BREAK = 'break';
  121.     public const ITEM_APPROVED = 'approved';
  123.     public const VG_CREATE = 'create';
  124.     public const VG_UPDATE = 'update';
  125.     public const VG_OPEN = 'open';
  126.     public const VG_CLOSE = 'close';
  128.     public const PATCH_TE_OPERATION = 'patch-te';
  130.     public function __construct()
  131.     {
  132.         $this->createdAt = new \DateTime();
  133.     }
  135.     #[Assert\NotNull(groups: [self::VG_CREATE])]
  136.     #[ApiProperty(description: 'начало', openapiContext: ['format' => 'date-time'])]
  137.     #[Groups(['TimeEntry:read', 'TimeEntry:write', 'Project:read'])]
  138.     #[ORM\Column(type: 'datetime', nullable: false, name: 'timer_start')]
  139.     private ?\DateTimeInterface $start = null;
  141.     #[ApiProperty(description: 'конец', openapiContext: ['format' => 'date-time'])]
  142.     #[Groups(['TimeEntry:read', 'TimeEntry:write', 'Project:read'])]
  143.     #[Assert\NotNull(groups: [self::VG_CLOSE, self::VG_CREATE])]
  144.     #[ORM\Column(type: 'datetime', nullable: true, name: 'timer_end')]
  145.     private ?\DateTimeInterface $end = null;
  147.     #[Assert\Valid]
  148.     #[Groups(['TimeEntry:read'])]
  149.     #[ORM\ManyToOne(targetEntity: 'App\Entity\User', inversedBy: 'timeEntries', cascade: ['persist'])]
  150.     private ?User $user = null;
  152.     #[Groups(['TimeEntry:read'])]
  153.     #[ORM\ManyToOne(targetEntity: 'App\Entity\Project\Project', inversedBy: 'timeEntries', cascade: ['persist'])]
  154.     #[ORM\JoinColumn(nullable: true)]
  155.     private ?Project $project = null;
  157.     #[Groups(['TimeEntry:read', 'TimeEntry:write', 'Project:read'])]
  158.     #[ORM\Column(type: 'text', nullable: true)]
  159.     private ?string $description = null;
  161.     #[Groups(['TimeEntry:read', 'TimeEntry:write', 'Project:read'])]
  162.     #[ORM\Column(type: 'string', nullable: true)]
  163.     private ?string $title = null;
  165.     #[Assert\Url]
  166.     #[Groups(['TimeEntry:read', 'TimeEntry:write', 'Project:read'])]
  167.     #[ORM\Column(type: 'string', nullable: true)]
  168.     private ?string $link = null;
  170.     #[Groups(['TimeEntry:read', 'TimeEntry:write', 'Project:read'])]
  171.     #[Assert\Valid(groups: [self::VG_CREATE, self::VG_UPDATE])]
  172.     #[Assert\NotNull(groups: [self::VG_CREATE, self::VG_UPDATE])]
  173.     #[ORM\ManyToOne(targetEntity: Task::class, inversedBy: 'timeEntries', cascade: ['persist'], fetch: 'EAGER')]
  174.     private ?Task $task = null;
  176.     #[Groups(['TimeEntry:read', 'TimeEntry:write', 'Project:read'])]
  177.     #[ApiProperty(description: 'защищена от изменений?')]
  178.     #[ORM\Column(type: 'boolean', options: ['default' => false, 'comment' => 'Change prohibition'])]
  179.     private bool $isFixed = false;
  181.     #[ORM\Column(type: 'datetimetz', nullable: true, name: 'timer_start_absolute')]
  182.     private ?\DateTimeInterface $startAbs = null;
  183.     #[ORM\Column(type: 'datetimetz', nullable: true, name: 'timer_end_absolute')]
  184.     private ?\DateTimeInterface $endAbs = null;
  186.     #[Groups(['TimeEntry:read', 'Project:read'])]
  187.     #[ApiProperty(description: 'подтверждение', deprecationReason: 'состояние подтверждения доступно в isApproved')]
  188.     #[ORM\OneToOne(targetEntity: TimeEntryValidation::class, mappedBy: 'timeEntry', fetch: 'EAGER', cascade: ['persist', 'remove'])]
  189.     private ?TimeEntryValidation $timeEntryValidation = null;
  191.     #[ORM\Column(type: 'datetime', nullable: true)]
  192.     private ?\DateTimeInterface $deletedAt = null;
  194.     public function __toString(): string
  195.     {
  196.         $from = $this->start !== null ? $this->start->format(\DateTimeInterface::ATOM) : 'Not defined';
  197.         $to = $this->end !== null ? $this->end->format(\DateTimeInterface::ATOM) : 'Not defined';
  199.         $username = 'Unknown user';
  200.         $user = $this->task?->getUser() ?? $this->user;
  201.         if ($user instanceof User) {
  202.             $username = $user->getUsername();
  203.             if (($profile = $user->getProfile()) instanceof Profile) {
  204.                 $username = $profile->getPerson()->getFullName();
  205.             }
  206.         }
  207.         $taskTitle = 'Unknown task';
  208.         if (($task = $this->task) instanceof Task) {
  209.             $taskTitle = \sprintf('%s – %s', $task->getTitle() ?? 'Unknown task', $task->getProject()?->getTitle() ?? 'Unknown project');
  210.         }
  212.         return \sprintf('%s – %s (%s, %s)', $from, $to, $taskTitle, $username);
  213.     }
  215.     #[Assert\Callback]
  216.     public function validate(ExecutionContextInterface $context): void
  217.     {
  218.         $maxAllowedDate = new \DateTime('now +12hour', new \DateTimeZone('UTC'));
  220.         if ($this->start > $maxAllowedDate) {
  221.             $context->buildViolation('Start date {{ start }} cannot be later than {{ now }}')
  222.                 ->setParameter('{{ start }}', $this->startAbs?->format(\DateTimeInterface::ATOM))
  223.                 ->setParameter('{{ now }}', $maxAllowedDate->format(\DateTimeInterface::ATOM))
  224.                 ->atPath('start')
  225.                 ->addViolation();
  226.         }
  228.         if (isset($this->end)) {
  229.             if ($this->end > $maxAllowedDate) {
  230.                 $context->buildViolation('End date {{ end }} cannot be later than {{ now }}')
  231.                     ->setParameter('{{ end }}', $this->endAbs?->format(\DateTimeInterface::ATOM))
  232.                     ->setParameter('{{ now }}', $maxAllowedDate->format(\DateTimeInterface::ATOM))
  233.                     ->atPath('end')
  234.                     ->addViolation();
  235.             }
  236.             if ($this->start >= $this->end) {
  237.                 $context->buildViolation('End of period {{ end }} must be later than start {{ start }}')
  238.                     ->setParameter('{{ start }}', $this->startAbs?->format(\DateTimeInterface::ATOM))
  239.                     ->setParameter('{{ end }}', $this->endAbs?->format(\DateTimeInterface::ATOM))
  240.                     ->atPath('start')
  241.                     ->addViolation();
  242.             }
  243.         }
  244.     }
  246.     public function getStart(): ?\DateTimeInterface
  247.     {
  248.         return DateTimeHelper::truncateSeconds($this->start);
  249.     }
  251.     public function setStart(\DateTimeInterface $start): self
  252.     {
  253.         $datetime = DateTimeHelper::truncateSeconds($start);
  254.         \is_null($datetime) ? $this->setStartAbs($start) : $this->setStartAbs($datetime);
  255.         $this->start = $datetime;
  257.         return $this;
  258.     }
  260.     public function getEnd(): ?\DateTimeInterface
  261.     {
  262.         return DateTimeHelper::truncateSeconds($this->end);
  263.     }
  265.     public function setEnd(\DateTimeInterface $datetime = null): self
  266.     {
  267.         $datetime = DateTimeHelper::truncateSeconds($datetime);
  268.         $this->setEndAbs($datetime);
  269.         $this->end = \is_null($datetime) ? $datetime : DateTimeHelper::recreateDateTimeWithTimeZoneUTC($datetime);
  271.         return $this;
  272.     }
  274.     public function getLength(): int
  275.     {
  276.         return $this->getTimeEntryMinutes($this);
  277.     }
  279.     /**
  280.      * длительность в минутах.
  281.      */
  282.     #[Groups(['TimeEntry:read', 'Project:read'])]
  283.     #[ApiProperty(description: 'длительность в минутах')]
  284.     public function getDuration(): int
  285.     {
  286.         return $this->getTimeEntryMinutes($this);
  287.     }
  289.     #[Groups(['TimeEntry:read', 'Project:read'])]
  290.     #[ApiProperty(description: 'подтвержденная длительность в минутах')]
  291.     public function getTimeMinute(): int
  292.     {
  293.         return $this->getIsApproved() ? $this->getTimeEntryMinutes($this) : 0;
  294.     }
  296.     #[Groups(['TimeEntry:read', 'Project:read'])]
  297.     #[ApiProperty(description: 'описание задачи')]
  298.     public function getTaskDescription(): ?string
  299.     {
  300.         return $this->getTask()?->getDescription();
  301.     }
  303.     public function getDescription(): ?string
  304.     {
  305.         return $this->description ?? $this->getTask()?->getDescription();
  306.     }
  308.     public function setDescription(?string $description): self
  309.     {
  310.         $this->description = $description;
  312.         return $this;
  313.     }
  315.     public function getTitle(): ?string
  316.     {
  317.         return $this->title ?? $this->getTask()?->getTitle();
  318.     }
  320.     public function setTitle(?string $title): self
  321.     {
  322.         $this->title = $title;
  324.         return $this;
  325.     }
  327.     public function getLink(): ?string
  328.     {
  329.         return $this->link ?? $this->getTask()?->getLink();
  330.     }
  332.     public function setLink(?string $link): self
  333.     {
  334.         $this->link = $link;
  336.         return $this;
  337.     }
  339.     public function getUser(): ?User
  340.     {
  341.         return $this->getTask()?->getUser() ?? $this->user;
  342.     }
  344.     public function setUser(?User $user): self
  345.     {
  346.         $this->user = $user;
  347.         if ($this->task instanceof Task) {
  348.             $this->task->setUser($user);
  349.         }
  351.         return $this;
  352.     }
  354.     public function getProject(): ?Project
  355.     {
  356.         return $this->getTask()?->getProject() ?? $this->project;
  357.     }
  359.     public function setProject(?Project $project): self
  360.     {
  361.         $this->project = $project;
  362.         if ($this->task instanceof Task) {
  363.             $this->task->setProject($project);
  364.         }
  366.         return $this;
  367.     }
  369.     public function getProjectName(): string
  370.     {
  371.         return $this->getProject()?->getTitle() ?? 'Unknown';
  372.     }
  374.     public function getTask(): ?Task
  375.     {
  376.         return $this->task;
  377.     }
  379.     public function setTask(?Task $task): TimeEntry
  380.     {
  381.         $this->task = $task;
  383.         return $this;
  384.     }
  386.     public function getIsFixed(): bool
  387.     {
  388.         return $this->isFixed;
  389.     }
  391.     public function setIsFixed(bool $isFixed): self
  392.     {
  393.         $this->isFixed = $isFixed;
  395.         return $this;
  396.     }
  398.     /**
  399.      * подтверждена?
  400.      */
  401.     #[Groups(['TimeEntry:read', 'Project:read'])]
  402.     #[ApiProperty(description: 'подтверждена?')]
  403.     public function getIsApproved(): bool
  404.     {
  405.         return $this->getTimeEntryValidation()?->getIsApproved() ?? false;
  406.     }
  408.     public function getStartAbs(): ?\DateTimeInterface
  409.     {
  410.         return $this->startAbs;
  411.     }
  413.     private function setStartAbs(\DateTimeInterface $start): self
  414.     {
  415.         $this->startAbs = clone $start;
  417.         return $this;
  418.     }
  420.     public function getEndAbs(): ?\DateTimeInterface
  421.     {
  422.         return $this->endAbs;
  423.     }
  425.     private function setEndAbs(?\DateTimeInterface $end): self
  426.     {
  427.         $this->endAbs = \is_null($end) ? $end : clone $end;
  429.         return $this;
  430.     }
  432.     public function getTimeEntryValidation(): ?TimeEntryValidation
  433.     {
  434.         return $this->timeEntryValidation;
  435.     }
  437.     public function setTimeEntryValidation(?TimeEntryValidation $timeEntryValidation): self
  438.     {
  439.         // set the owning side of the relation if necessary
  440.         if ($timeEntryValidation && $timeEntryValidation->getTimeEntry() !== $this) {
  441.             $timeEntryValidation->setTimeEntry($this);
  442.         }
  444.         $this->timeEntryValidation = $timeEntryValidation;
  446.         return $this;
  447.     }
  449.     public function getDeletedAt(): ?\DateTimeInterface
  450.     {
  451.         return $this->deletedAt;
  452.     }
  454.     public function setDeletedAt(?\DateTimeInterface $deletedAt): void
  455.     {
  456.         $this->deletedAt = $deletedAt;
  457.     }
  458. }