src/Entity/WorkerActivities.php line 22

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\WorkerActivitiesRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Doctrine\ORM\PersistentCollection;
  10. use phpDocumentor\Reflection\Types\This;
  11. use Monolog\DateTimeImmutable;
  12. use Symfony\Component\Serializer\Annotation\MaxDepth;
  13. use function PHPUnit\Framework\returnArgument;
  14. use Symfony\Component\Serializer\Annotation\Groups;
  16. // Criteria olustur...
  17. use Doctrine\Common\Collections\Criteria;
  19. /**
  20.  * @ORM\Entity(repositoryClass=WorkerActivitiesRepository::class)
  21.  */
  22. class WorkerActivities
  23. {
  24.     /**
  25.      * @ORM\Id
  26.      * @ORM\GeneratedValue
  27.      * @ORM\Column(type="integer")
  28.      * @Groups({
  29.      *      "worker.activity.core", "worker_activity@core",
  30.      *      "customer.smart.active.employees",
  31.      *      "worker.manage.base",
  32.      *      "worker.actually.activity",
  33.      *      "timesheet.for.stakeholder",
  34.      *      "timesheet.for.customer",
  35.      *      "customer.selected.project",
  36.      *
  37.      *      "timesheet.collected.base",
  38.      *
  39.      *      "worker.in.project.worker.activity.base",
  40.      *
  41.      *
  42.      *      "worker.activity.substitution.worker.activity.core"
  43.      * })
  44.      */
  45.     private $id;
  47.     /**
  48.      * @ORM\ManyToOne(targetEntity=Worker::class, inversedBy="workerActivities" )
  49.      * // INFO Since cascade={"remove"} ignores the foreign key references by explicitly deleting the record.
  50.      * @ORM\JoinColumn(nullable=true, onDelete="CASCADE")
  51.      * @Groups({
  52.      *     "customer.smart.active.employees",
  53.      *     "worker.manage.base",
  54.      *     "timesheet.for.stakeholder",
  55.      *     "timesheet.for.customer",
  56.      *     "customer.selected.project",
  57.      *
  58.      *     "timesheet.collected.base",
  59.      *
  60.      *     "worker.in.project.worker.activity.worker",
  61.      *
  62.      *     "worker.activity.substitution.worker.activity.worker",
  63.      *
  64.      *     "worker.activity.worker",
  65.      *
  66.      *     "worker_activity@worker",
  67.      *
  68.      *     })
  69.      * @ORM\OrderBy({"name" = "ASC"})
  70.      */
  71.     private $worker;
  73.     /**
  74.      * @ORM\Column(type="datetime_immutable", nullable=true)
  75.      * @Groups({
  76.      *     "customer.smart.active.employees",
  77.      *     "worker.manage.base",
  78.      *     "worker.actually.activity",
  79.      *
  80.      *     "worker.activity.core",
  81.      *
  82.      *     "worker_activity@core"
  83.      * })
  84.      */
  85.     private $entry_at;
  87.     /**
  88.      * @ORM\Column(type="datetime_immutable", nullable=true)
  89.      * @Groups({
  90.      *     "customer.smart.active.employees",
  91.      *     "worker.manage.base",
  92.      *     "worker.actually.activity",
  93.      *
  94.      *     "worker.activity.core",
  95.      *
  96.      *      "worker_activity@core"
  97.      * })
  98.      */
  99.     private $exit_at;
  101.     /**
  102.      * @ORM\Column(type="datetime_immutable", nullable=true)
  103.      * @Groups({
  104.      *     "worker_activity@core"
  105.      * })
  106.      */
  107.     private $created_at;
  109.     /**
  110.      * @ORM\ManyToOne(targetEntity=Customer::class, inversedBy="workerActivities")
  111.      * @ORM\JoinColumn(nullable=false, onDelete="CASCADE")
  112.      * @Groups({
  113.      *     "worker.actually.activity",
  114.      *     "timesheet.for.stakeholder",
  115.      *     "customer.selected.project",
  116.      *
  117.      *     "worker.in.project.worker.activity.customer",
  118.      *
  119.      *     "worker.activity.customer",
  120.      *
  121.      *     "worker_activity@customer"
  122.      *
  123.      *
  124.      *     })
  125.      */
  126.     private $customer;
  128.     /**
  129.      * @Groups({"customer.smart.active.employees", "worker.manage.base" })
  130.     */
  131.     private $editable;
  133.     /**
  134.      * @Groups({"customer.smart.active.employees", "worker.manage.base"})
  135.     */
  136.     private $status;
  138.     /**
  139.      * @deprecated use timesheets instead
  140.      * @ORM\OneToMany(targetEntity=WorkerTimesheet::class, mappedBy="worker_activity")
  141.      *
  142.      * @Groups({
  143.      *       "worker.manage.base.timesheet",
  144.      *       "timesheet.for.stakeholder",
  145.      *       "timesheet.for.customer",
  146.      *
  147.      *       "project.joined.stakeholder.worker.in.project.worker.activity.timesheet",
  148.      *
  149.      *
  150.      *
  151.      *       })
  152.      */
  153.     private $worker_timesheets;
  155.     /**
  156.      * @ORM\OneToMany(targetEntity=WorkerInProject::class, mappedBy="worker_activity", orphanRemoval=true, fetch="EXTRA_LAZY")
  157.      * @ORM\OrderBy({"id":"DESC"})
  158.      * @Groups({"worker.manage.base", "worker.manage.joined.projects"})
  159.      *
  160.      */
  161.     private $worker_in_projects;
  163.     /**
  164.      * @ORM\Column(type="boolean", nullable=true)
  165.      * @Groups({
  166.      *     "worker.manage.base",
  167.      *     "customer.smart.active.employees",
  168.      *     "timesheet.for.stakeholder",
  169.      *     })
  170.      */
  171.     private $guest;
  173.     /**
  174.      * @ORM\OneToMany(targetEntity=WorkerTimesheetPayments::class, mappedBy="worker_activity", orphanRemoval=true, cascade={"persist", "remove"} )
  175.      * @Groups({"worker.manage.base.timesheet.payments"})
  176.      */
  177.     private $worker_timesheet_payments;
  179.     /**
  180.      * TODO this should be in WorkerActivities
  181.      * @ORM\OneToMany(targetEntity=ProjectOrders::class, mappedBy="order_primary_lead")
  182.      */
  183.     private $projectOrders;
  185.     /**
  186.      *
  187.      *      Bu yapı, WorkerActivities (İşçi Aktiviteleri) tablosunda bir aktivitenin başka bir aktiviteyle ilişkili
  188.      *      olduğunu belirtmek için kullanılır.
  189.      *      Bu, özellikle bir işçinin yokluğunda onun yerine geçen başka bir işçinin aktivitesini takip etmek için
  190.      *      faydalıdır.
  191.      *
  192.      * 🧱   Teknik Açıklama
  193.      *      ManyToMany İlişki: Bir aktivite birden fazla aktiviteyle ilişkili olabilir ve tersi de geçerlidir.
  194.      *      Self-Referencing: İlişki aynı tablo (WorkerActivities) içinde tanımlanmıştır.
  195.      *      JoinTable: İlişkiyi temsil eden ara tablo manuel olarak adlandırılmıştır: worker_activity_substitutions.
  196.      *      joinColumns: İlişkinin sahibi olan aktiviteyi belirtir.
  197.      *      inverseJoinColumns: İlişkinin hedefi olan aktiviteyi belirtir.
  198.      *
  199.      *      This property defines the activities that this activity *replaces* or *substitutes*.
  200.      *
  201.      *      In other words, if a worker cannot perform their original activity (e.g., due to absence),
  202.      *      this activity can take over those responsibilities. This allows tracking which activities
  203.      *      serve as substitutes for others.
  204.      *
  205.      *      The relationship is many-to-many and self-referencing within the WorkerActivities entity.
  206.      *
  207.      *      For example:
  208.      *      - Activity A substitutes Activity B and C.
  209.      *      - Activity B is substituted by Activity A.
  210.      *
  211.      *      This is the owning side of the relation.
  212.      * @MaxDepth(1)
  213.      * @ORM\ManyToMany(targetEntity=WorkerActivities::class, inversedBy="worker_substituted_activities")
  214.      * @ORM\JoinTable(
  215.      *      name="worker_activity_substitutions",
  216.      *      joinColumns={@ORM\JoinColumn(name="main_activity_id", referencedColumnName="id")},
  217.      *      inverseJoinColumns={@ORM\JoinColumn(name="substituted_activity_id", referencedColumnName="id")}
  218.      *  )
  219.      * @Groups({
  220.      *        "worker.activity.substitutions",
  221.      *    })
  222.     */
  223.     private $worker_activity_substitutions;
  225.     /**
  226.      * @MaxDepth(1)
  227.      * @ORM\ManyToMany(targetEntity=WorkerActivities::class, mappedBy="worker_activity_substitutions")
  228.      * @Groups({
  229.      *          "worker.activity.coverages",
  230.      * })
  231.      */
  232.     private $worker_substituted_activities;
  234.     /**
  235.      * @ORM\ManyToOne(targetEntity=User::class, inversedBy="worker_activities")
  236.      * @Groups({
  237.      *     "worker.activity.user"
  238.      *     })
  239.      * @ORM\JoinColumn(onDelete="SET NULL")
  240.      */
  241.     private $user;
  243.     /**
  244.      * @ORM\Column(type="boolean", nullable=true, options={"comment": "Indicates whether the worker is accountable for the profitability performance of the Aufträge they participated in. If true, the worker's success/failure will be evaluated based on whether the project met its profit margin targets. ( Bu işçinin görev aldığı Aufträg'ların kâr hedefine ulaşıp ulaşmamasıyla ilişkilendirilmesini sağlayan bilgi alanı.)"} )
  245.      * @Groups({
  246.      *     "worker.manage.base",
  247.      *     "worker.activity.core", "worker_activity@core",
  248.      *     "customer.smart.active.employees",
  249.      *
  250.      *     "worker_activity@core"
  251.      * })
  252.      */
  253.     private $is_kpi_responsible;
  255.     /**
  256.      * @ORM\ManyToMany(targetEntity=ProjectOrders::class, mappedBy="assigned_workers")
  257.      */
  258.     private $assigned_orders;
  260.     /**
  261.      * @ORM\OneToMany(targetEntity=Timesheets::class, mappedBy="worker_activity", orphanRemoval=true)
  262.      */
  263.     private $timesheets;
  265.     /**
  266.      * @ORM\Column(type="string", length=255, nullable=true)
  267.      * @Groups({
  268.      *      "worker.activity.core",
  269.      *
  270.      *      "worker_activity@core"
  271.      *  })
  272.      *
  273.      */
  274.     private $termination_reason;
  277. //    /**
  278. //     * Private param
  279. //     * @Groups({
  280. //     *           "worker.last.activity",
  281. //     *  })
  282. //     */
  283. //    private $last_activity;
  284. //
  285. //    /**
  286. //     * @return mixed
  287. //     */
  288. //    public function getLastActivity()
  289. //    {
  290. //        $criteria = Criteria::create();
  291. //        $criteria->orderBy(['created_at' => Criteria::DESC])->setMaxResults(1);
  292. //
  293. //        /**@var WorkerActivities $latestActivity*/
  294. //        $latestActivity = $this->getWorker()->getWorkerActivities()->matching($criteria)->first();
  295. //
  296. //        #dd(334);
  297. //        return $latestActivity->getId() ?? null;
  298. //
  299. ////        $all_activities = $this->getWorker()->getWorkerActivities()->toArray();
  300. ////        usort($all_activities, fn($a, $b) => $b['created_at'] <=> $a['created_at']); // ID'ye göre azalan sıralama
  301. ////        return $all_activities[0] ?? null; // ID'si en büyük olan
  302. //    }
  306.     public function __construct()
  307.     {
  308.         $this->worker_timesheets = new ArrayCollection();
  309.         $this->worker_in_projects = new ArrayCollection();
  310.         $this->worker_timesheet_payments = new ArrayCollection();
  311.         $this->projectOrders = new ArrayCollection();
  312.         $this->worker_activity_substitutions = new ArrayCollection();
  313.         $this->worker_substituted_activities = new ArrayCollection();
  314.         $this->assigned_orders = new ArrayCollection();
  315.         $this->timesheets = new ArrayCollection();;
  316.     }
  319.     /**
  320.      * @Groups("customer.workers.smart.list")
  321.     */
  322.     public function getEditable(): bool {
  323.         return !($this->getExitAt() && $this->getExitAt() < new \DateTimeImmutable('now'));;
  324.     }
  326.     public function getStatus(): ?array {
  328.         if( !$this->getEntryAt() && !$this->getExitAt() ){
  329.             return [
  330.                 'status' => 'unknown',
  331.                 'color' => 'yellow',
  332.                 'message' => 'Unknown status'
  333.             ];
  334.         } else if( $this->getEntryAt() && !$this->getExitAt() ){
  335.             return [
  336.                 'status' => 'active',
  337.                 'color' => 'green',
  338.                 'message' => "Active since " . (new DateTimeImmutable('now'))->diff( $this->getEntryAt())->days . ' day(s)'
  339.             ];
  340.         }
  341.         else {
  343.             $today = new \DateTimeImmutable('now');
  344.             $exitAt = $this->getExitAt();
  345.             if( $exitAt && $today < $exitAt ){
  346.                 $restDay = $exitAt->diff( $today )->days;
  347.                 if( !$restDay ){
  348.                     return [
  349.                         'status' => 'inactive',
  350.                         'color' => 'red',
  351.                         'message' => "Inactive in " . $exitAt->diff( $today )->h . " Hour(s)"
  352.                     ];
  353.                 }
  355.                 return [
  356.                     'status' => 'inactive',
  357.                     'color' => 'red',
  358.                     'message' => "Inactive in " . $restDay . " Day(s)"
  359.                 ];
  360.             }
  361.         }
  363.         return [
  364.             'status' => 'inactive',
  365.             'color' => 'red',
  366.             'message' => "Inactive since " . (new DateTimeImmutable('now'))->diff( $this->getExitAt())->days . ' day(s)'
  367.         ];
  369.     }
  371.     public function getCompanyName(): ?string{
  372.         return $this->getCustomer()->getCompany();
  373.     }
  375.     public function getId(): ?int
  376.     {
  377.         return $this->id;
  378.     }
  380.     public function getWorker(): ?Worker
  381.     {
  382.         return $this->worker;
  383.     }
  385.     public function setWorker(?Worker $worker): self
  386.     {
  387.         $this->worker = $worker;
  389.         return $this;
  390.     }
  392.     public function getEntryAt(): ?\DateTimeImmutable
  393.     {
  394.         return $this->entry_at;
  395.     }
  397.     public function setEntryAt(?\DateTimeImmutable $entry_at): self
  398.     {
  399.         $this->entry_at = $entry_at;
  401.         return $this;
  402.     }
  404.     public function getExitAt(): ?\DateTimeImmutable
  405.     {
  406.         return $this->exit_at;
  407.     }
  409.     public function setExitAt(?\DateTimeImmutable $exit_at): self
  410.     {
  411.         $this->exit_at = $exit_at;
  413.         return $this;
  414.     }
  416.     public function getCreatedAt(): ?\DateTimeImmutable
  417.     {
  418.         return $this->created_at;
  419.     }
  421.     public function setCreatedAt(?\DateTimeImmutable $created_at): self
  422.     {
  423.         $this->created_at = $created_at;
  425.         return $this;
  426.     }
  428.     public function getCustomer(): ?Customer
  429.     {
  430.         return $this->customer;
  431.     }
  433.     public function setCustomer(?Customer $customer): self
  434.     {
  435.         $this->customer = $customer;
  437.         return $this;
  438.     }
  440.     /**
  441.      * @return Collection<int, WorkerTimesheet>
  442.      */
  443.     public function getWorkerTimesheets(): Collection
  444.     {
  445.         return $this->worker_timesheets;
  446.     }
  448.     public function addWorkerTimesheet(WorkerTimesheet $workerTimesheet): self
  449.     {
  450.         if (!$this->worker_timesheets->contains($workerTimesheet)) {
  451.             $this->worker_timesheets[] = $workerTimesheet;
  452.             $workerTimesheet->setWorkerActivity($this);
  453.         }
  455.         return $this;
  456.     }
  458.     public function removeWorkerTimesheet(WorkerTimesheet $workerTimesheet): self
  459.     {
  460.         if ($this->worker_timesheets->removeElement($workerTimesheet)) {
  461.             // set the owning side to null (unless already changed)
  462.             if ($workerTimesheet->getWorkerActivity() === $this) {
  463.                 $workerTimesheet->setWorkerActivity(null);
  464.             }
  465.         }
  467.         return $this;
  468.     }
  470.     /**
  471.      * @return Collection<int, WorkerInProject>
  472.      */
  473.     public function getWorkerInProjects(): ?Collection
  474.     {
  475.         return $this->worker_in_projects;
  476.     }
  478.     public function addWorkerInProject(WorkerInProject $workerInProject): self
  479.     {
  480.         if (!$this->worker_in_projects->contains($workerInProject)) {
  481.             $this->worker_in_projects[] = $workerInProject;
  482.             $workerInProject->setWorker($this);
  483.         }
  485.         return $this;
  486.     }
  488.     public function removeWorkerInProject(WorkerInProject $workerInProject): self
  489.     {
  490.         if ($this->worker_in_projects->removeElement($workerInProject)) {
  491.             // set the owning side to null (unless already changed)
  492.             if ($workerInProject->getWorker() === $this) {
  493.                 $workerInProject->setWorker(null);
  494.             }
  495.         }
  497.         return $this;
  498.     }
  500.     public function isGuest(): ?bool
  501.     {
  502.         return $this->guest;
  503.     }
  505.     public function setGuest(?bool $guest): self
  506.     {
  507.         $this->guest = $guest;
  509.         return $this;
  510.     }
  512.     /**
  513.      * @return Collection<int, WorkerTimesheetPayments>
  514.      */
  515.     public function getWorkerTimesheetpayments(): Collection
  516.     {
  517.         return $this->worker_timesheet_payments;
  518.     }
  520.     public function addWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
  521.     {
  522.         if (!$this->worker_timesheet_payments->contains($workerTimesheetPayment)) {
  523.             $this->worker_timesheet_payments[] = $workerTimesheetPayment;
  524.             $workerTimesheetPayment->setWorkerActivity($this);
  525.         }
  526.         return $this;
  527.     }
  529.     public function removeWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
  530.     {
  531.         if ($this->worker_timesheet_payments->removeElement($workerTimesheetPayment)) {
  532.             // set the owning side to null (unless already changed)
  533.             if ($workerTimesheetPayment->getWorkerActivity() === $this) {
  534.                 $workerTimesheetPayment->setWorkerActivity(null);
  535.             }
  536.         }
  537.         return $this;
  538.     }
  540.     /**
  541.      * @return Collection<int, ProjectOrders>
  542.      */
  543.     public function getProjectOrders(): Collection
  544.     {
  545.         return $this->projectOrders;
  546.     }
  548.     public function addProjectOrder(ProjectOrders $projectOrder): self
  549.     {
  550.         if (!$this->projectOrders->contains($projectOrder)) {
  551.             $this->projectOrders[] = $projectOrder;
  552.             $projectOrder->setOrderLead($this);
  553.         }
  555.         return $this;
  556.     }
  558.     public function removeProjectOrder(ProjectOrders $projectOrder): self
  559.     {
  560.         if ($this->projectOrders->removeElement($projectOrder)) {
  561.             // set the owning side to null (unless already changed)
  562.             if ($projectOrder->getOrderLead() === $this) {
  563.                 $projectOrder->setOrderLead(null);
  564.             }
  565.         }
  567.         return $this;
  568.     }
  570.     /**
  571.      * @return Collection<int, self>
  572.      */
  573.     public function getWorkerActivitySubstitutions(): Collection
  574.     {
  575.         return $this->worker_activity_substitutions;
  576.     }
  578.     public function addWorkerSubstitutedActivity(self $workerSubstitutedActivity): self
  579.     {
  580.         if (!$this->worker_activity_substitutions->contains($workerSubstitutedActivity)) {
  581.             $this->worker_activity_substitutions[] = $workerSubstitutedActivity;
  582.         }
  584.         return $this;
  585.     }
  587.     public function removeWorkerSubstitutedActivity(self $workerSubstitutedActivity): self
  588.     {
  589.         $this->worker_activity_substitutions->removeElement($workerSubstitutedActivity);
  591.         return $this;
  592.     }
  594.     /**
  595.      * @return Collection<int, self>
  596.      */
  597.     public function getWorkerSubstitutedActivities(): Collection
  598.     {
  599.         return $this->worker_substituted_activities;
  600.     }
  602.     public function getUser(): ?User
  603.     {
  604.         return $this->user;
  605.     }
  607.     public function setUser(?User $user): self
  608.     {
  609.         $this->user = $user;
  611.         return $this;
  612.     }
  614.     public function isIsKpiResponsible(): ?bool
  615.     {
  616.         return $this->is_kpi_responsible;
  617.     }
  619.     public function setIsKpiResponsible(?bool $is_kpi_responsible): self
  620.     {
  621.         $this->is_kpi_responsible = $is_kpi_responsible;
  623.         return $this;
  624.     }
  626.     /**
  627.      * @return Collection<int, ProjectOrders>
  628.      */
  629.     public function getAssignedOrders(): Collection
  630.     {
  631.         return $this->assigned_orders;
  632.     }
  634.     public function addAssignedOrder(ProjectOrders $assignedOrder): self
  635.     {
  636.         if (!$this->assigned_orders->contains($assignedOrder)) {
  637.             $this->assigned_orders[] = $assignedOrder;
  638.             $assignedOrder->addAssignedWorker($this);
  639.         }
  641.         return $this;
  642.     }
  644.     public function removeAssignedOrder(ProjectOrders $assignedOrder): self
  645.     {
  646.         if ($this->assigned_orders->removeElement($assignedOrder)) {
  647.             $assignedOrder->removeAssignedWorker($this);
  648.         }
  650.         return $this;
  651.     }
  653.     /**
  654.      * @return Collection<int, Timesheets>
  655.      */
  656.     public function getTimesheets(): Collection
  657.     {
  658.         return $this->timesheets;
  659.     }
  661.     public function addTimesheet(Timesheets $timesheet): self
  662.     {
  663.         if (!$this->timesheets->contains($timesheet)) {
  664.             $this->timesheets[] = $timesheet;
  665.             $timesheet->setWorkerActivity($this);
  666.         }
  668.         return $this;
  669.     }
  671.     public function removeTimesheet(Timesheets $timesheet): self
  672.     {
  673.         if ($this->timesheets->removeElement($timesheet)) {
  674.             // set the owning side to null (unless already changed)
  675.             if ($timesheet->getWorkerActivity() === $this) {
  676.                 $timesheet->setWorkerActivity(null);
  677.             }
  678.         }
  680.         return $this;
  681.     }
  683.     public function getTerminationReason(): ?string
  684.     {
  685.         return $this->termination_reason;
  686.     }
  688.     public function setTerminationReason(?string $termination_reason): self
  689.     {
  690.         $this->termination_reason = $termination_reason;
  692.         return $this;
  693.     }
  695. }