src/Entity/WorkerActivities.php line 23

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\Common\Collections\Selectable;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Doctrine\ORM\PersistentCollection;
  11. use phpDocumentor\Reflection\Types\This;
  12. use Monolog\DateTimeImmutable;
  13. use Symfony\Component\Serializer\Annotation\MaxDepth;
  14. use function PHPUnit\Framework\returnArgument;
  15. use Symfony\Component\Serializer\Annotation\Groups;
  17. // Criteria olustur...
  18. use Doctrine\Common\Collections\Criteria;
  20. /**
  21.  * @ORM\Entity(repositoryClass=WorkerActivitiesRepository::class)
  22.  */
  23. class WorkerActivities
  24. {
  25.     /**
  26.      * @ORM\Id
  27.      * @ORM\GeneratedValue
  28.      * @ORM\Column(type="integer")
  29.      * @Groups({
  30.      *      "worker.activity.core",
  31.      *      "partner.smart.active.employees",
  32.      *      "worker.manage.base",
  33.      *      "worker.actually.activity",
  34.      *      "timesheet.for.stakeholder",
  35.      *      "timesheet.for.partner",
  36.      *      "partner.selected.project",
  37.      *
  38.      *      "timesheet.collected.base",
  39.      *
  40.      *      "worker.in.project.worker.activity.base",
  41.      *
  42.      *
  43.      *      "worker.activity.substitution.worker.activity.core",
  44.      *
  45.      *     "worker_activity@core",
  46.      *     "worker_activity@base"
  47.      *
  48.      * })
  49.      */
  50.     private $id;
  52.     /**
  53.      * @ORM\ManyToOne(targetEntity=Worker::class, inversedBy="worker_activities" )
  54.      * // INFO Since cascade={"remove"} ignores the foreign key references by explicitly deleting the record.
  55.      * @ORM\JoinColumn(nullable=true, onDelete="CASCADE")
  56.      * @Groups({
  57.      *     "partner.smart.active.employees",
  58.      *     "worker.manage.base",
  59.      *     "timesheet.for.stakeholder",
  60.      *     "timesheet.for.partner",
  61.      *     "partner.selected.project",
  62.      *
  63.      *     "timesheet.collected.base",
  64.      *
  65.      *     "worker.in.project.worker.activity.worker",
  66.      *
  67.      *     "worker.activity.substitution.worker.activity.worker",
  68.      *
  69.      *     "worker.activity.worker",
  70.      *
  71.      *     "worker_activity@worker",
  72.      *
  73.      *     })
  74.      * @ORM\OrderBy({"name" = "ASC"})
  75.      */
  76.     private $worker;
  78.     /**
  79.      * @ORM\Column(type="datetime_immutable", nullable=true)
  80.      * @Groups({
  81.      *     "partner.smart.active.employees",
  82.      *     "worker.manage.base",
  83.      *     "worker.actually.activity",
  84.      *
  85.      *     "worker.activity.core",
  86.      *
  87.      *     "worker_activity@core"
  88.      * })
  89.      */
  90.     private $entry_at;
  92.     /**
  93.      * @ORM\Column(type="datetime_immutable", nullable=true)
  94.      * @Groups({
  95.      *     "partner.smart.active.employees",
  96.      *     "worker.manage.base",
  97.      *     "worker.actually.activity",
  98.      *
  99.      *     "worker.activity.core",
  100.      *
  101.      *      "worker_activity@core",
  102.      * })
  103.      */
  104.     private $exit_at;
  106.     /**
  107.      * @ORM\Column(type="datetime_immutable", nullable=true)
  108.      * @Groups({
  109.      *     "worker_activity@core"
  110.      * })
  111.      */
  112.     private $created_at;
  114.     /**
  115.      * @ORM\ManyToOne(targetEntity=Partner::class, inversedBy="worker_activities")
  116.      * @ORM\JoinColumn(nullable=false, onDelete="CASCADE")
  117.      * @Groups({
  118.      *     "worker.actually.activity",
  119.      *     "timesheet.for.stakeholder",
  120.      *     "partner.selected.project",
  121.      *
  122.      *     "worker.in.project.worker.activity.partner",
  123.      *
  124.      *     "worker.activity.partner",
  125.      *
  126.      *     "worker_activity@partner"
  127.      *
  128.      *
  129.      *     })
  130.      */
  131.     private $partner;
  133.     /**
  134.      * @Groups({
  135.      *     "partner.smart.active.employees",
  136.      *     "worker.manage.base"
  137.      * })
  138.     */
  139.     private $editable;
  141.     /**
  142.      * @Groups({
  143.      *     "partner.smart.active.employees",
  144.      *     "worker.manage.base",
  145.      *
  146.      * })
  147.     */
  148.     private $status;
  150.     /**
  151.      * @deprecated use timesheets instead
  152.      * @ORM\OneToMany(targetEntity=WorkerTimesheet::class, mappedBy="worker_activity", cascade={"persist", "remove"})
  153.      *
  154.      * @Groups({
  155.      *     "worker.manage.base.timesheet",
  156.      *     "timesheet.for.stakeholder",
  157.      *     "timesheet.for.partner",
  158.      *
  159.      *     "project.joined.stakeholder.worker.in.project.worker.activity.timesheet",
  160.      *
  161.      *
  162.      * })
  163.      */
  164.     private $worker_timesheets;
  166.     /**
  167.      * @MaxDepth(1)
  168.      * @ORM\OneToMany(targetEntity=WorkerInProject::class, mappedBy="worker_activity", orphanRemoval=true, fetch="EXTRA_LAZY")
  169.      * @ORM\OrderBy({"id":"DESC"})
  170.      * @Groups({
  171.      *     "worker.manage.base",
  172.      *     "worker.manage.joined.projects",
  173.      *     "worker_activity@worker_in_project",
  174.      * })
  175.      *
  176.      */
  177.     private $worker_in_projects;
  179.     /**
  180.      * @ORM\Column(type="boolean", nullable=true)
  181.      * @Groups({
  182.      *     "worker.manage.base",
  183.      *     "partner.smart.active.employees",
  184.      *     "timesheet.for.stakeholder",
  185.      *
  186.      *     "worker_activity@core"
  187.      * })
  188.      */
  189.     private $guest;
  191.     /**
  192.      * @ORM\OneToMany(targetEntity=WorkerTimesheetPayments::class, mappedBy="worker_activity", orphanRemoval=true, cascade={"persist", "remove"} )
  193.      * @Groups({
  194.      *     "worker.manage.base.timesheet.payments",
  195.      *
  196.      *     "worker_activity@worker_timesheet_payments"
  197.      * })
  198.      */
  199.     private $worker_timesheet_payments;
  201.     /**
  202.      * TODO this should be in WorkerActivities
  203.      * @ORM\OneToMany(targetEntity=ProjectOrders::class, mappedBy="order_primary_lead")
  204.      */
  205.     private $projectOrders;
  207.     /**
  208.      *
  209.      *      Bu yapı, WorkerActivities (İşçi Aktiviteleri) tablosunda bir aktivitenin başka bir aktiviteyle ilişkili
  210.      *      olduğunu belirtmek için kullanılır.
  211.      *      Bu, özellikle bir işçinin yokluğunda onun yerine geçen başka bir işçinin aktivitesini takip etmek için
  212.      *      faydalıdır.
  213.      *
  214.      * 🧱   Teknik Açıklama
  215.      *      ManyToMany İlişki: Bir aktivite birden fazla aktiviteyle ilişkili olabilir ve tersi de geçerlidir.
  216.      *      Self-Referencing: İlişki aynı tablo (WorkerActivities) içinde tanımlanmıştır.
  217.      *      JoinTable: İlişkiyi temsil eden ara tablo manuel olarak adlandırılmıştır: worker_activity_substitutions.
  218.      *      joinColumns: İlişkinin sahibi olan aktiviteyi belirtir.
  219.      *      inverseJoinColumns: İlişkinin hedefi olan aktiviteyi belirtir.
  220.      *
  221.      *      This property defines the activities that this activity *replaces* or *substitutes*.
  222.      *
  223.      *      In other words, if a worker cannot perform their original activity (e.g., due to absence),
  224.      *      this activity can take over those responsibilities. This allows tracking which activities
  225.      *      serve as substitutes for others.
  226.      *
  227.      *      The relationship is many-to-many and self-referencing within the WorkerActivities entity.
  228.      *
  229.      *      For example:
  230.      *      - Activity A substitutes Activity B and C.
  231.      *      - Activity B is substituted by Activity A.
  232.      *
  233.      *      This is the owning side of the relation.
  234.      * @MaxDepth(1)
  235.      * @ORM\ManyToMany(targetEntity=WorkerActivities::class, inversedBy="worker_substituted_activities")
  236.      * @ORM\JoinTable(
  237.      *      name="worker_activity_substitutions",
  238.      *      joinColumns={@ORM\JoinColumn(name="main_activity_id", referencedColumnName="id")},
  239.      *      inverseJoinColumns={@ORM\JoinColumn(name="substituted_activity_id", referencedColumnName="id")}
  240.      *  )
  241.      * @Groups({
  242.      *     "worker.activity.substitutions",
  243.      *
  244.      *     "worker_activity@worker_activity_substitutions"
  245.      * })
  246.     */
  247.     private $worker_activity_substitutions;
  249.     /**
  250.      * @MaxDepth(1)
  251.      * @ORM\ManyToMany(targetEntity=WorkerActivities::class, mappedBy="worker_activity_substitutions")
  252.      * @Groups({
  253.      *     "worker.activity.coverages",
  254.      *
  255.      *     "worker_activity@worker_substituted_activities"
  256.      * })
  257.      */
  258.     private $worker_substituted_activities;
  260.     /**
  261.      * @ORM\ManyToOne(targetEntity=User::class, inversedBy="worker_activities")
  262.      * @Groups({
  263.      *     "worker.activity.user",
  264.      *
  265.      *     "worker_activity@user"
  266.      * })
  267.      * @ORM\JoinColumn(onDelete="SET NULL")
  268.      */
  269.     private $user;
  271.     /**
  272.      * @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ı.)"} )
  273.      * @Groups({
  274.      *     "worker.manage.base",
  275.      *     "worker.activity.core", "worker_activity@core",
  276.      *     "partner.smart.active.employees",
  277.      *
  278.      *     "worker_activity@core"
  279.      * })
  280.      */
  281.     private $is_kpi_responsible;
  283.     /**
  284.      * @ORM\ManyToMany(targetEntity=ProjectOrders::class, mappedBy="assigned_workers")
  285.      */
  286.     private $assigned_orders;
  288.     /**
  289.      * TODO Temporarily Durduruldu Baglanti Entityler Entity_Archived icinde!
  290.      * ORM\OneToMany(targetEntity=Timesheets::class, mappedBy="worker_activity", orphanRemoval=true)
  291.      * @Groups({
  292.      *     "worker_activity@timesheets",
  293.      * })
  294.      */
  295.     private $timesheets;
  297.     /**
  298.      * @ORM\Column(type="string", length=255, nullable=true)
  299.      * @Groups({
  300.      *      "worker.activity.core",
  301.      *
  302.      *      "worker_activity@core"
  303.      *  })
  304.      *
  305.      */
  306.     private $termination_reason;
  309.     /**
  310.      * Setter over Subscriber
  311.      * @Groups({
  312.      *      "worker_activity@core"
  313.      *  })
  314.      */
  315.     private $activity_status;
  318.     /**
  319.      * @ORM\Column(type="float", nullable=true)
  320.      * @Groups({
  321.      *       "worker_activity@core"
  322.      * })
  323.      */
  324.     private $hourly_rate;
  326.     /**
  327.      * @ORM\Column(type="float", nullable=true)
  328.      * @Groups({
  329.      *        "worker_activity@core"
  330.      * })
  331.      */
  332.     private $daily_working_hours;
  334.     /**
  335.      * @ORM\OneToMany(targetEntity=StockIssue::class, mappedBy="issue_to_employee_activity")
  336.      */
  337.     private $stockIssues;
  339.     /**
  340.      * @ORM\OneToMany(targetEntity=ProjectOrderTasks::class, mappedBy="responsible_person")
  341.      */
  342.     private $project_order_tasks;
  344.     /**
  345.      * @ORM\OneToMany(targetEntity=ProjectOrderTaskFulfillment::class, mappedBy="branch_contact_person")
  346.      */
  347.     private $project_order_task_fulfillments;
  349.     /**
  350.      * Controle over Subscriber
  351.      * @return mixed
  352.      */
  353.     public function getActivityStatus()
  354.     {
  355.         return $this->activity_status;
  356.     }
  358.     /**
  359.      * Controle over Subscriber
  360.      * @param mixed $activity_status
  361.      */
  362.     public function setActivityStatus($activity_status): self
  363.     {
  364.         $this->activity_status = $activity_status;
  365.         return $this;
  366.     }
  369.     public function __construct()
  370.     {
  371.         $this->worker_timesheets = new ArrayCollection();
  372.         $this->worker_in_projects = new ArrayCollection();
  373.         $this->worker_timesheet_payments = new ArrayCollection();
  374.         $this->projectOrders = new ArrayCollection();
  375.         $this->worker_activity_substitutions = new ArrayCollection();
  376.         $this->worker_substituted_activities = new ArrayCollection();
  377.         $this->assigned_orders = new ArrayCollection();
  378.         $this->timesheets = new ArrayCollection();
  379.         $this->stockIssues = new ArrayCollection();
  380.         $this->project_order_tasks = new ArrayCollection();
  381.         $this->project_order_task_fulfillments = new ArrayCollection();;
  382.     }
  385.     /**
  386.      * @Groups("partner.workers.smart.list")
  387.     */
  388.     public function getEditable(): bool {
  389.         return !($this->getExitAt() && $this->getExitAt() < new \DateTimeImmutable('now'));;
  390.     }
  392.     public function getStatus(): ?array {
  394.         if( !$this->getEntryAt() && !$this->getExitAt() ){
  395.             return [
  396.                 'status' => 'unknown',
  397.                 'color' => 'yellow',
  398.                 'message' => 'Unknown status'
  399.             ];
  400.         } else if( $this->getEntryAt() && !$this->getExitAt() ){
  401.             return [
  402.                 'status' => 'active',
  403.                 'color' => 'green',
  404.                 'message' => "Active since " . (new DateTimeImmutable('now'))->diff( $this->getEntryAt())->days . ' day(s)'
  405.             ];
  406.         }
  407.         else {
  409.             $today = new \DateTimeImmutable('now');
  410.             $exitAt = $this->getExitAt();
  411.             if( $exitAt && $today < $exitAt ){
  412.                 $restDay = $exitAt->diff( $today )->days;
  413.                 if( !$restDay ){
  414.                     return [
  415.                         'status' => 'inactive',
  416.                         'color' => 'red',
  417.                         'message' => "Inactive in " . $exitAt->diff( $today )->h . " Hour(s)"
  418.                     ];
  419.                 }
  421.                 return [
  422.                     'status' => 'inactive',
  423.                     'color' => 'red',
  424.                     'message' => "Inactive in " . $restDay . " Day(s)"
  425.                 ];
  426.             }
  427.         }
  429.         return [
  430.             'status' => 'inactive',
  431.             'color' => 'red',
  432.             'message' => "Inactive since " . (new DateTimeImmutable('now'))->diff( $this->getExitAt())->days . ' day(s)'
  433.         ];
  435.     }
  437.     public function getCompanyName(): ?string{
  438.         return $this->getPartner()->getCompany();
  439.     }
  441.     public function getId(): ?int
  442.     {
  443.         return $this->id;
  444.     }
  446.     public function getWorker(): ?Worker
  447.     {
  448.         return $this->worker;
  449.     }
  451.     public function setWorker(?Worker $worker): self
  452.     {
  453.         $this->worker = $worker;
  455.         return $this;
  456.     }
  458.     public function getEntryAt(): ?\DateTimeImmutable
  459.     {
  460.         return $this->entry_at;
  461.     }
  463.     public function setEntryAt(?\DateTimeImmutable $entry_at): self
  464.     {
  465.         $this->entry_at = $entry_at;
  467.         return $this;
  468.     }
  470.     public function getExitAt(): ?\DateTimeImmutable
  471.     {
  472.         return $this->exit_at;
  473.     }
  475.     public function setExitAt(?\DateTimeImmutable $exit_at): self
  476.     {
  477.         $this->exit_at = $exit_at;
  479.         return $this;
  480.     }
  482.     public function getCreatedAt(): ?\DateTimeImmutable
  483.     {
  484.         return $this->created_at;
  485.     }
  487.     public function setCreatedAt(?\DateTimeImmutable $created_at): self
  488.     {
  489.         $this->created_at = $created_at;
  491.         return $this;
  492.     }
  494.     public function getPartner(): ?Partner
  495.     {
  496.         return $this->partner;
  497.     }
  499.     public function setPartner(?Partner $partner): self
  500.     {
  501.         $this->partner = $partner;
  503.         return $this;
  504.     }
  506.     /**
  507.      * @return Collection<int, WorkerTimesheet>&Selectable
  508.      */
  509.     public function getWorkerTimesheets(): Collection
  510.     {
  511.         return $this->worker_timesheets;
  512.     }
  514.     public function addWorkerTimesheet(WorkerTimesheet $workerTimesheet): self
  515.     {
  516.         if (!$this->worker_timesheets->contains($workerTimesheet)) {
  517.             $this->worker_timesheets[] = $workerTimesheet;
  518.             $workerTimesheet->setWorkerActivity($this);
  519.         }
  521.         return $this;
  522.     }
  524.     public function removeWorkerTimesheet(WorkerTimesheet $workerTimesheet): self
  525.     {
  526.         if ($this->worker_timesheets->removeElement($workerTimesheet)) {
  527.             // set the owning side to null (unless already changed)
  528.             if ($workerTimesheet->getWorkerActivity() === $this) {
  529.                 $workerTimesheet->setWorkerActivity(null);
  530.             }
  531.         }
  533.         return $this;
  534.     }
  536.     /**
  537.      * @return Collection<int, WorkerInProject>&Selectable
  538.      */
  539.     public function getWorkerInProjects(): ?Collection
  540.     {
  541.         return $this->worker_in_projects;
  542.     }
  544.     public function addWorkerInProject(WorkerInProject $workerInProject): self
  545.     {
  546.         // dd($workerInProject);
  548.         if (!$this->worker_in_projects->contains($workerInProject)) {
  549.             $this->worker_in_projects[] = $workerInProject;
  550.             // $workerInProject->setWorker($this);
  551.             // $workerInProject->setStakeholderProject($this);
  552.             // $workerInProject->setProject($this);
  553.             $workerInProject->setWorkerActivity($this);
  554.         }
  556.         return $this;
  557.     }
  559.     public function removeWorkerInProject(WorkerInProject $workerInProject): self
  560.     {
  561.         if ($this->worker_in_projects->removeElement($workerInProject)) {
  562.             // set the owning side to null (unless already changed)
  563. //             if ($workerInProject->getWorker() === $this) {
  564. //                 $workerInProject->setWorker(null);
  565. //             }
  566.             if ($workerInProject->getWorkerActivity() === $this) {
  567.                 $workerInProject->setWorkerActivity(null);
  568.             }
  569.         }
  571.         return $this;
  572.     }
  574.     public function isGuest(): ?bool
  575.     {
  576.         return $this->guest;
  577.     }
  579.     public function setGuest(?bool $guest): self
  580.     {
  581.         $this->guest = $guest;
  583.         return $this;
  584.     }
  586.     /**
  587.      * @return Collection<int, WorkerTimesheetPayments>
  588.      */
  589.     public function getWorkerTimesheetpayments(): Collection
  590.     {
  591.         return $this->worker_timesheet_payments;
  592.     }
  594.     public function addWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
  595.     {
  596.         if (!$this->worker_timesheet_payments->contains($workerTimesheetPayment)) {
  597.             $this->worker_timesheet_payments[] = $workerTimesheetPayment;
  598.             $workerTimesheetPayment->setWorkerActivity($this);
  599.         }
  600.         return $this;
  601.     }
  603.     public function removeWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
  604.     {
  605.         if ($this->worker_timesheet_payments->removeElement($workerTimesheetPayment)) {
  606.             // set the owning side to null (unless already changed)
  607.             if ($workerTimesheetPayment->getWorkerActivity() === $this) {
  608.                 $workerTimesheetPayment->setWorkerActivity(null);
  609.             }
  610.         }
  611.         return $this;
  612.     }
  614.     /**
  615.      * @return Collection<int, ProjectOrders>
  616.      */
  617.     public function getProjectOrders(): Collection
  618.     {
  619.         return $this->projectOrders;
  620.     }
  622.     public function addProjectOrder(ProjectOrders $projectOrder): self
  623.     {
  624.         if (!$this->projectOrders->contains($projectOrder)) {
  625.             $this->projectOrders[] = $projectOrder;
  626.             $projectOrder->setOrderLead($this);
  627.         }
  629.         return $this;
  630.     }
  632.     public function removeProjectOrder(ProjectOrders $projectOrder): self
  633.     {
  634.         if ($this->projectOrders->removeElement($projectOrder)) {
  635.             // set the owning side to null (unless already changed)
  636.             if ($projectOrder->getOrderLead() === $this) {
  637.                 $projectOrder->setOrderLead(null);
  638.             }
  639.         }
  641.         return $this;
  642.     }
  644.     /**
  645.      * @return Collection<int, self>
  646.      */
  647.     public function getWorkerActivitySubstitutions(): Collection
  648.     {
  649.         return $this->worker_activity_substitutions;
  650.     }
  652.     public function addWorkerSubstitutedActivity(self $workerSubstitutedActivity): self
  653.     {
  654.         if (!$this->worker_activity_substitutions->contains($workerSubstitutedActivity)) {
  655.             $this->worker_activity_substitutions[] = $workerSubstitutedActivity;
  656.         }
  658.         return $this;
  659.     }
  661.     public function removeWorkerSubstitutedActivity(self $workerSubstitutedActivity): self
  662.     {
  663.         $this->worker_activity_substitutions->removeElement($workerSubstitutedActivity);
  665.         return $this;
  666.     }
  668.     /**
  669.      * @return Collection<int, self>
  670.      */
  671.     public function getWorkerSubstitutedActivities(): Collection
  672.     {
  673.         return $this->worker_substituted_activities;
  674.     }
  676.     public function getUser(): ?User
  677.     {
  678.         return $this->user;
  679.     }
  681.     public function setUser(?User $user): self
  682.     {
  683.         $this->user = $user;
  685.         return $this;
  686.     }
  688.     public function isIsKpiResponsible(): ?bool
  689.     {
  690.         return $this->is_kpi_responsible;
  691.     }
  693.     public function setIsKpiResponsible(?bool $is_kpi_responsible): self
  694.     {
  695.         $this->is_kpi_responsible = $is_kpi_responsible;
  697.         return $this;
  698.     }
  700.     /**
  701.      * @return Collection<int, ProjectOrders>&Selectable
  702.      */
  703.     public function getAssignedOrders(): Collection
  704.     {
  705.         return $this->assigned_orders;
  706.     }
  708.     public function addAssignedOrder(ProjectOrders $assignedOrder): self
  709.     {
  710.         if (!$this->assigned_orders->contains($assignedOrder)) {
  711.             $this->assigned_orders[] = $assignedOrder;
  712.             $assignedOrder->addAssignedWorker($this);
  713.         }
  715.         return $this;
  716.     }
  718.     public function removeAssignedOrder(ProjectOrders $assignedOrder): self
  719.     {
  720.         if ($this->assigned_orders->removeElement($assignedOrder)) {
  721.             $assignedOrder->removeAssignedWorker($this);
  722.         }
  724.         return $this;
  725.     }
  727.     /**
  728.      * @return Collection<int, Timesheets>&Selectable
  729.      */
  730.     public function getTimesheets(): ?Collection
  731.     {
  732.         return $this->timesheets;
  733.     }
  735.     public function addTimesheet(Timesheets $timesheet): self
  736.     {
  737.         if (!$this->timesheets->contains($timesheet)) {
  738.             $this->timesheets[] = $timesheet;
  739.             $timesheet->setWorkerActivity($this);
  740.         }
  742.         return $this;
  743.     }
  745.     public function removeTimesheet(Timesheets $timesheet): self
  746.     {
  747.         if ($this->timesheets->removeElement($timesheet)) {
  748.             // set the owning side to null (unless already changed)
  749.             if ($timesheet->getWorkerActivity() === $this) {
  750.                 $timesheet->setWorkerActivity(null);
  751.             }
  752.         }
  754.         return $this;
  755.     }
  757.     public function getTerminationReason(): ?string
  758.     {
  759.         return $this->termination_reason;
  760.     }
  762.     public function setTerminationReason(?string $termination_reason): self
  763.     {
  764.         $this->termination_reason = $termination_reason;
  766.         return $this;
  767.     }
  769.     public function getHourlyRate(): ?float
  770.     {
  771.         return $this->hourly_rate;
  772.     }
  774.     public function setHourlyRate(?float $hourly_rate): self
  775.     {
  776.         $this->hourly_rate = $hourly_rate;
  778.         return $this;
  779.     }
  781.     /**
  782.      * @return Collection<int, StockIssue>
  783.      */
  784.     public function getStockIssues(): Collection
  785.     {
  786.         return $this->stockIssues;
  787.     }
  789.     public function addStockIssue(StockIssue $stockIssue): self
  790.     {
  791.         if (!$this->stockIssues->contains($stockIssue)) {
  792.             $this->stockIssues[] = $stockIssue;
  793.             $stockIssue->setIssueToEmployeeActivity($this);
  794.         }
  796.         return $this;
  797.     }
  799.     public function removeStockIssue(StockIssue $stockIssue): self
  800.     {
  801.         if ($this->stockIssues->removeElement($stockIssue)) {
  802.             // set the owning side to null (unless already changed)
  803.             if ($stockIssue->getIssueToEmployeeActivity() === $this) {
  804.                 $stockIssue->setIssueToEmployeeActivity(null);
  805.             }
  806.         }
  808.         return $this;
  809.     }
  811.     public function getDailyWorkingHours(): ?float
  812.     {
  813.         return $this->daily_working_hours;
  814.     }
  816.     public function setDailyWorkingHours(?float $daily_working_hours): self
  817.     {
  818.         $this->daily_working_hours = $daily_working_hours;
  820.         return $this;
  821.     }
  823.     /**
  824.      * @return Collection<int, ProjectOrderTasks>
  825.      */
  826.     public function getProjectOrderTasks(): Collection
  827.     {
  828.         return $this->project_order_tasks;
  829.     }
  831.     public function addProjectOrderTask(ProjectOrderTasks $projectOrderTask): self
  832.     {
  833.         if (!$this->project_order_tasks->contains($projectOrderTask)) {
  834.             $this->project_order_tasks[] = $projectOrderTask;
  835.             $projectOrderTask->setResponsiblePerson($this);
  836.         }
  838.         return $this;
  839.     }
  841.     public function removeProjectOrderTask(ProjectOrderTasks $projectOrderTask): self
  842.     {
  843.         if ($this->project_order_tasks->removeElement($projectOrderTask)) {
  844.             // set the owning side to null (unless already changed)
  845.             if ($projectOrderTask->getResponsiblePerson() === $this) {
  846.                 $projectOrderTask->setResponsiblePerson(null);
  847.             }
  848.         }
  850.         return $this;
  851.     }
  853.     /**
  854.      * @return Collection<int, ProjectOrderTaskFulfillment>
  855.      */
  856.     public function getProjectOrderTaskFulfillments(): Collection
  857.     {
  858.         return $this->project_order_task_fulfillments;
  859.     }
  861.     public function addProjectOrderTaskFulfillment(ProjectOrderTaskFulfillment $projectOrderTaskFulfillment): self
  862.     {
  863.         if (!$this->project_order_task_fulfillments->contains($projectOrderTaskFulfillment)) {
  864.             $this->project_order_task_fulfillments[] = $projectOrderTaskFulfillment;
  865.             $projectOrderTaskFulfillment->setBranchContactPerson($this);
  866.         }
  868.         return $this;
  869.     }
  871.     public function removeProjectOrderTaskFulfillment(ProjectOrderTaskFulfillment $projectOrderTaskFulfillment): self
  872.     {
  873.         if ($this->project_order_task_fulfillments->removeElement($projectOrderTaskFulfillment)) {
  874.             // set the owning side to null (unless already changed)
  875.             if ($projectOrderTaskFulfillment->getBranchContactPerson() === $this) {
  876.                 $projectOrderTaskFulfillment->setBranchContactPerson(null);
  877.             }
  878.         }
  880.         return $this;
  881.     }
  883. }