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.      * Yıl bazında izin hakkı + önceki yıldan devir (kullanıcı kararı 2026-09-19 — sözleşme bazlı).
  203.      * Günler burada DEĞİL (Timesheet `H`); bkz. WorkerActivityLeaveEntitlement doc-block'u.
  204.      *
  205.      * @ORM\OneToMany(targetEntity=WorkerActivityLeaveEntitlement::class, mappedBy="worker_activity", orphanRemoval=true, cascade={"persist", "remove"})
  206.      * @ORM\OrderBy({"year":"DESC"})
  207.      * @Groups({
  208.      *     "worker_activity@leave_entitlements"
  209.      * })
  210.      */
  211.     private $leave_entitlements;
  213.     /**
  214.      * TODO this should be in WorkerActivities
  215.      * @ORM\OneToMany(targetEntity=ProjectOrders::class, mappedBy="order_primary_lead")
  216.      */
  217.     private $projectOrders;
  219.     /**
  220.      *
  221.      *      Bu yapı, WorkerActivities (İşçi Aktiviteleri) tablosunda bir aktivitenin başka bir aktiviteyle ilişkili
  222.      *      olduğunu belirtmek için kullanılır.
  223.      *      Bu, özellikle bir işçinin yokluğunda onun yerine geçen başka bir işçinin aktivitesini takip etmek için
  224.      *      faydalıdır.
  225.      *
  226.      * 🧱   Teknik Açıklama
  227.      *      ManyToMany İlişki: Bir aktivite birden fazla aktiviteyle ilişkili olabilir ve tersi de geçerlidir.
  228.      *      Self-Referencing: İlişki aynı tablo (WorkerActivities) içinde tanımlanmıştır.
  229.      *      JoinTable: İlişkiyi temsil eden ara tablo manuel olarak adlandırılmıştır: worker_activity_substitutions.
  230.      *      joinColumns: İlişkinin sahibi olan aktiviteyi belirtir.
  231.      *      inverseJoinColumns: İlişkinin hedefi olan aktiviteyi belirtir.
  232.      *
  233.      *      This property defines the activities that this activity *replaces* or *substitutes*.
  234.      *
  235.      *      In other words, if a worker cannot perform their original activity (e.g., due to absence),
  236.      *      this activity can take over those responsibilities. This allows tracking which activities
  237.      *      serve as substitutes for others.
  238.      *
  239.      *      The relationship is many-to-many and self-referencing within the WorkerActivities entity.
  240.      *
  241.      *      For example:
  242.      *      - Activity A substitutes Activity B and C.
  243.      *      - Activity B is substituted by Activity A.
  244.      *
  245.      *      This is the owning side of the relation.
  246.      * @MaxDepth(1)
  247.      * @ORM\ManyToMany(targetEntity=WorkerActivities::class, inversedBy="worker_substituted_activities")
  248.      * @ORM\JoinTable(
  249.      *      name="worker_activity_substitutions",
  250.      *      joinColumns={@ORM\JoinColumn(name="main_activity_id", referencedColumnName="id")},
  251.      *      inverseJoinColumns={@ORM\JoinColumn(name="substituted_activity_id", referencedColumnName="id")}
  252.      *  )
  253.      * @Groups({
  254.      *     "worker.activity.substitutions",
  255.      *
  256.      *     "worker_activity@worker_activity_substitutions"
  257.      * })
  258.     */
  259.     private $worker_activity_substitutions;
  261.     /**
  262.      * @MaxDepth(1)
  263.      * @ORM\ManyToMany(targetEntity=WorkerActivities::class, mappedBy="worker_activity_substitutions")
  264.      * @Groups({
  265.      *     "worker.activity.coverages",
  266.      *
  267.      *     "worker_activity@worker_substituted_activities"
  268.      * })
  269.      */
  270.     private $worker_substituted_activities;
  272.     /**
  273.      * @ORM\ManyToOne(targetEntity=User::class, inversedBy="worker_activities")
  274.      * @Groups({
  275.      *     "worker.activity.user",
  276.      *
  277.      *     "worker_activity@user"
  278.      * })
  279.      * @ORM\JoinColumn(onDelete="SET NULL")
  280.      */
  281.     private $user;
  283.     /**
  284.      * @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ı.)"} )
  285.      * @Groups({
  286.      *     "worker.manage.base",
  287.      *     "worker.activity.core", "worker_activity@core",
  288.      *     "partner.smart.active.employees",
  289.      *
  290.      *     "worker_activity@core"
  291.      * })
  292.      */
  293.     private $is_kpi_responsible;
  295.     /**
  296.      * @ORM\ManyToMany(targetEntity=ProjectOrders::class, mappedBy="assigned_workers")
  297.      */
  298.     private $assigned_orders;
  300.     /**
  301.      * TODO Temporarily Durduruldu Baglanti Entityler Entity_Archived icinde!
  302.      * ORM\OneToMany(targetEntity=Timesheets::class, mappedBy="worker_activity", orphanRemoval=true)
  303.      * @Groups({
  304.      *     "worker_activity@timesheets",
  305.      * })
  306.      */
  307.     private $timesheets;
  309.     /**
  310.      * @ORM\Column(type="string", length=255, nullable=true)
  311.      * @Groups({
  312.      *      "worker.activity.core",
  313.      *
  314.      *      "worker_activity@core"
  315.      *  })
  316.      *
  317.      */
  318.     private $termination_reason;
  321.     /**
  322.      * Setter over Subscriber
  323.      * @Groups({
  324.      *      "worker_activity@core"
  325.      *  })
  326.      */
  327.     private $activity_status;
  330.     /**
  331.      * Iscinin BU aktivitedeki saat ucreti — kademeli zincirin 1. halkasi.
  332.      * Doluysa tartisma biter; bos ise sirasiyla firma ucreti (iscinin PRIMARY niteligi icin,
  333.      * `partner_qualification_rate`) ve global ayar (`qualification.default_hourly_rate`) onerilir.
  334.      * Tek okuma noktasi: `App\Service\HourlyRateResolver`.
  335.      *
  336.      * @ORM\Column(type="float", nullable=true)
  337.      * @Groups({
  338.      *       "worker_activity@core"
  339.      * })
  340.      */
  341.     private $hourly_rate;
  344.     /**
  345.      * @ORM\Column(type="float", nullable=true)
  346.      * @Groups({
  347.      *        "worker_activity@core"
  348.      * })
  349.      */
  350.     private $daily_working_hours;
  352.     /**
  353.      * @ORM\OneToMany(targetEntity=StockIssue::class, mappedBy="issue_to_employee_activity")
  354.      */
  355.     private $stockIssues;
  357.     /**
  358.      * @ORM\OneToMany(targetEntity=ProjectOrderTasks::class, mappedBy="responsible_person")
  359.      */
  360.     private $project_order_tasks;
  362.     /**
  363.      * @ORM\OneToMany(targetEntity=ProjectOrderTaskFulfillment::class, mappedBy="branch_contact_person")
  364.      */
  365.     private $project_order_task_fulfillments;
  367.     /**
  368.      * Controle over Subscriber
  369.      * @return mixed
  370.      */
  371.     public function getActivityStatus()
  372.     {
  373.         return $this->activity_status;
  374.     }
  376.     /**
  377.      * Controle over Subscriber
  378.      * @param mixed $activity_status
  379.      */
  380.     public function setActivityStatus($activity_status): self
  381.     {
  382.         $this->activity_status = $activity_status;
  383.         return $this;
  384.     }
  387.     public function __construct()
  388.     {
  389.         $this->leave_entitlements = new ArrayCollection();
  390.         $this->worker_timesheets = new ArrayCollection();
  391.         $this->worker_in_projects = new ArrayCollection();
  392.         $this->worker_timesheet_payments = new ArrayCollection();
  393.         $this->projectOrders = new ArrayCollection();
  394.         $this->worker_activity_substitutions = new ArrayCollection();
  395.         $this->worker_substituted_activities = new ArrayCollection();
  396.         $this->assigned_orders = new ArrayCollection();
  397.         $this->timesheets = new ArrayCollection();
  398.         $this->stockIssues = new ArrayCollection();
  399.         $this->project_order_tasks = new ArrayCollection();
  400.         $this->project_order_task_fulfillments = new ArrayCollection();;
  401.     }
  404.     /**
  405.      * @Groups("partner.workers.smart.list")
  406.     */
  407.     public function getEditable(): bool {
  408.         return !($this->getExitAt() && $this->getExitAt() < new \DateTimeImmutable('now'));;
  409.     }
  411.     public function getStatus(): ?array {
  413.         if( !$this->getEntryAt() && !$this->getExitAt() ){
  414.             return [
  415.                 'status' => 'unknown',
  416.                 'color' => 'yellow',
  417.                 'message' => 'Unknown status'
  418.             ];
  419.         } else if( $this->getEntryAt() && !$this->getExitAt() ){
  420.             return [
  421.                 'status' => 'active',
  422.                 'color' => 'green',
  423.                 'message' => "Active since " . (new DateTimeImmutable('now'))->diff( $this->getEntryAt())->days . ' day(s)'
  424.             ];
  425.         }
  426.         else {
  428.             $today = new \DateTimeImmutable('now');
  429.             $exitAt = $this->getExitAt();
  430.             if( $exitAt && $today < $exitAt ){
  431.                 $restDay = $exitAt->diff( $today )->days;
  432.                 if( !$restDay ){
  433.                     return [
  434.                         'status' => 'inactive',
  435.                         'color' => 'red',
  436.                         'message' => "Inactive in " . $exitAt->diff( $today )->h . " Hour(s)"
  437.                     ];
  438.                 }
  440.                 return [
  441.                     'status' => 'inactive',
  442.                     'color' => 'red',
  443.                     'message' => "Inactive in " . $restDay . " Day(s)"
  444.                 ];
  445.             }
  446.         }
  448.         return [
  449.             'status' => 'inactive',
  450.             'color' => 'red',
  451.             'message' => "Inactive since " . (new DateTimeImmutable('now'))->diff( $this->getExitAt())->days . ' day(s)'
  452.         ];
  454.     }
  456.     public function getCompanyName(): ?string{
  457.         return $this->getPartner()->getCompany();
  458.     }
  460.     public function getId(): ?int
  461.     {
  462.         return $this->id;
  463.     }
  465.     public function getWorker(): ?Worker
  466.     {
  467.         return $this->worker;
  468.     }
  470.     public function setWorker(?Worker $worker): self
  471.     {
  472.         $this->worker = $worker;
  474.         return $this;
  475.     }
  477.     public function getEntryAt(): ?\DateTimeImmutable
  478.     {
  479.         return $this->entry_at;
  480.     }
  482.     public function setEntryAt(?\DateTimeImmutable $entry_at): self
  483.     {
  484.         $this->entry_at = $entry_at;
  486.         return $this;
  487.     }
  489.     public function getExitAt(): ?\DateTimeImmutable
  490.     {
  491.         return $this->exit_at;
  492.     }
  494.     public function setExitAt(?\DateTimeImmutable $exit_at): self
  495.     {
  496.         $this->exit_at = $exit_at;
  498.         return $this;
  499.     }
  501.     public function getCreatedAt(): ?\DateTimeImmutable
  502.     {
  503.         return $this->created_at;
  504.     }
  506.     public function setCreatedAt(?\DateTimeImmutable $created_at): self
  507.     {
  508.         $this->created_at = $created_at;
  510.         return $this;
  511.     }
  513.     public function getPartner(): ?Partner
  514.     {
  515.         return $this->partner;
  516.     }
  518.     public function setPartner(?Partner $partner): self
  519.     {
  520.         $this->partner = $partner;
  522.         return $this;
  523.     }
  525.     /**
  526.      * @return Collection<int, WorkerTimesheet>&Selectable
  527.      */
  528.     public function getWorkerTimesheets(): Collection
  529.     {
  530.         return $this->worker_timesheets;
  531.     }
  533.     public function addWorkerTimesheet(WorkerTimesheet $workerTimesheet): self
  534.     {
  535.         if (!$this->worker_timesheets->contains($workerTimesheet)) {
  536.             $this->worker_timesheets[] = $workerTimesheet;
  537.             $workerTimesheet->setWorkerActivity($this);
  538.         }
  540.         return $this;
  541.     }
  543.     public function removeWorkerTimesheet(WorkerTimesheet $workerTimesheet): self
  544.     {
  545.         if ($this->worker_timesheets->removeElement($workerTimesheet)) {
  546.             // set the owning side to null (unless already changed)
  547.             if ($workerTimesheet->getWorkerActivity() === $this) {
  548.                 $workerTimesheet->setWorkerActivity(null);
  549.             }
  550.         }
  552.         return $this;
  553.     }
  555.     /**
  556.      * @return Collection<int, WorkerInProject>&Selectable
  557.      */
  558.     public function getWorkerInProjects(): ?Collection
  559.     {
  560.         return $this->worker_in_projects;
  561.     }
  563.     public function addWorkerInProject(WorkerInProject $workerInProject): self
  564.     {
  565.         // dd($workerInProject);
  567.         if (!$this->worker_in_projects->contains($workerInProject)) {
  568.             $this->worker_in_projects[] = $workerInProject;
  569.             // $workerInProject->setWorker($this);
  570.             // $workerInProject->setStakeholderProject($this);
  571.             // $workerInProject->setProject($this);
  572.             $workerInProject->setWorkerActivity($this);
  573.         }
  575.         return $this;
  576.     }
  578.     public function removeWorkerInProject(WorkerInProject $workerInProject): self
  579.     {
  580.         if ($this->worker_in_projects->removeElement($workerInProject)) {
  581.             // set the owning side to null (unless already changed)
  582. //             if ($workerInProject->getWorker() === $this) {
  583. //                 $workerInProject->setWorker(null);
  584. //             }
  585.             if ($workerInProject->getWorkerActivity() === $this) {
  586.                 $workerInProject->setWorkerActivity(null);
  587.             }
  588.         }
  590.         return $this;
  591.     }
  593.     public function isGuest(): ?bool
  594.     {
  595.         return $this->guest;
  596.     }
  598.     public function setGuest(?bool $guest): self
  599.     {
  600.         $this->guest = $guest;
  602.         return $this;
  603.     }
  605.     /**
  606.      * @return Collection<int, WorkerTimesheetPayments>
  607.      */
  608.     public function getWorkerTimesheetpayments(): Collection
  609.     {
  610.         return $this->worker_timesheet_payments;
  611.     }
  613.     public function addWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
  614.     {
  615.         if (!$this->worker_timesheet_payments->contains($workerTimesheetPayment)) {
  616.             $this->worker_timesheet_payments[] = $workerTimesheetPayment;
  617.             $workerTimesheetPayment->setWorkerActivity($this);
  618.         }
  619.         return $this;
  620.     }
  622.     public function removeWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
  623.     {
  624.         if ($this->worker_timesheet_payments->removeElement($workerTimesheetPayment)) {
  625.             // set the owning side to null (unless already changed)
  626.             if ($workerTimesheetPayment->getWorkerActivity() === $this) {
  627.                 $workerTimesheetPayment->setWorkerActivity(null);
  628.             }
  629.         }
  630.         return $this;
  631.     }
  633.     /**
  634.      * @return Collection<int, ProjectOrders>
  635.      */
  636.     public function getProjectOrders(): Collection
  637.     {
  638.         return $this->projectOrders;
  639.     }
  641.     public function addProjectOrder(ProjectOrders $projectOrder): self
  642.     {
  643.         if (!$this->projectOrders->contains($projectOrder)) {
  644.             $this->projectOrders[] = $projectOrder;
  645.             $projectOrder->setOrderLead($this);
  646.         }
  648.         return $this;
  649.     }
  651.     public function removeProjectOrder(ProjectOrders $projectOrder): self
  652.     {
  653.         if ($this->projectOrders->removeElement($projectOrder)) {
  654.             // set the owning side to null (unless already changed)
  655.             if ($projectOrder->getOrderLead() === $this) {
  656.                 $projectOrder->setOrderLead(null);
  657.             }
  658.         }
  660.         return $this;
  661.     }
  663.     /**
  664.      * @return Collection<int, self>
  665.      */
  666.     public function getWorkerActivitySubstitutions(): Collection
  667.     {
  668.         return $this->worker_activity_substitutions;
  669.     }
  671.     public function addWorkerSubstitutedActivity(self $workerSubstitutedActivity): self
  672.     {
  673.         if (!$this->worker_activity_substitutions->contains($workerSubstitutedActivity)) {
  674.             $this->worker_activity_substitutions[] = $workerSubstitutedActivity;
  675.         }
  677.         return $this;
  678.     }
  680.     public function removeWorkerSubstitutedActivity(self $workerSubstitutedActivity): self
  681.     {
  682.         $this->worker_activity_substitutions->removeElement($workerSubstitutedActivity);
  684.         return $this;
  685.     }
  687.     /**
  688.      * @return Collection<int, self>
  689.      */
  690.     public function getWorkerSubstitutedActivities(): Collection
  691.     {
  692.         return $this->worker_substituted_activities;
  693.     }
  695.     public function getUser(): ?User
  696.     {
  697.         return $this->user;
  698.     }
  700.     public function setUser(?User $user): self
  701.     {
  702.         $this->user = $user;
  704.         return $this;
  705.     }
  707.     public function isIsKpiResponsible(): ?bool
  708.     {
  709.         return $this->is_kpi_responsible;
  710.     }
  712.     public function setIsKpiResponsible(?bool $is_kpi_responsible): self
  713.     {
  714.         $this->is_kpi_responsible = $is_kpi_responsible;
  716.         return $this;
  717.     }
  719.     /**
  720.      * @return Collection<int, ProjectOrders>&Selectable
  721.      */
  722.     public function getAssignedOrders(): Collection
  723.     {
  724.         return $this->assigned_orders;
  725.     }
  727.     public function addAssignedOrder(ProjectOrders $assignedOrder): self
  728.     {
  729.         if (!$this->assigned_orders->contains($assignedOrder)) {
  730.             $this->assigned_orders[] = $assignedOrder;
  731.             $assignedOrder->addAssignedWorker($this);
  732.         }
  734.         return $this;
  735.     }
  737.     public function removeAssignedOrder(ProjectOrders $assignedOrder): self
  738.     {
  739.         if ($this->assigned_orders->removeElement($assignedOrder)) {
  740.             $assignedOrder->removeAssignedWorker($this);
  741.         }
  743.         return $this;
  744.     }
  746.     /**
  747.      * @return Collection<int, Timesheets>&Selectable
  748.      */
  749.     public function getTimesheets(): ?Collection
  750.     {
  751.         return $this->timesheets;
  752.     }
  754.     public function addTimesheet(Timesheets $timesheet): self
  755.     {
  756.         if (!$this->timesheets->contains($timesheet)) {
  757.             $this->timesheets[] = $timesheet;
  758.             $timesheet->setWorkerActivity($this);
  759.         }
  761.         return $this;
  762.     }
  764.     public function removeTimesheet(Timesheets $timesheet): self
  765.     {
  766.         if ($this->timesheets->removeElement($timesheet)) {
  767.             // set the owning side to null (unless already changed)
  768.             if ($timesheet->getWorkerActivity() === $this) {
  769.                 $timesheet->setWorkerActivity(null);
  770.             }
  771.         }
  773.         return $this;
  774.     }
  776.     public function getTerminationReason(): ?string
  777.     {
  778.         return $this->termination_reason;
  779.     }
  781.     public function setTerminationReason(?string $termination_reason): self
  782.     {
  783.         $this->termination_reason = $termination_reason;
  785.         return $this;
  786.     }
  788.     public function getHourlyRate(): ?float
  789.     {
  790.         return $this->hourly_rate;
  791.     }
  793.     public function setHourlyRate(?float $hourly_rate): self
  794.     {
  795.         $this->hourly_rate = $hourly_rate;
  797.         return $this;
  798.     }
  801.     /**
  802.      * @return Collection<int, StockIssue>
  803.      */
  804.     public function getStockIssues(): Collection
  805.     {
  806.         return $this->stockIssues;
  807.     }
  809.     public function addStockIssue(StockIssue $stockIssue): self
  810.     {
  811.         if (!$this->stockIssues->contains($stockIssue)) {
  812.             $this->stockIssues[] = $stockIssue;
  813.             $stockIssue->setIssueToEmployeeActivity($this);
  814.         }
  816.         return $this;
  817.     }
  819.     public function removeStockIssue(StockIssue $stockIssue): self
  820.     {
  821.         if ($this->stockIssues->removeElement($stockIssue)) {
  822.             // set the owning side to null (unless already changed)
  823.             if ($stockIssue->getIssueToEmployeeActivity() === $this) {
  824.                 $stockIssue->setIssueToEmployeeActivity(null);
  825.             }
  826.         }
  828.         return $this;
  829.     }
  831.     public function getDailyWorkingHours(): ?float
  832.     {
  833.         return $this->daily_working_hours;
  834.     }
  836.     public function setDailyWorkingHours(?float $daily_working_hours): self
  837.     {
  838.         $this->daily_working_hours = $daily_working_hours;
  840.         return $this;
  841.     }
  843.     /**
  844.      * @return Collection<int, ProjectOrderTasks>
  845.      */
  846.     public function getProjectOrderTasks(): Collection
  847.     {
  848.         return $this->project_order_tasks;
  849.     }
  851.     public function addProjectOrderTask(ProjectOrderTasks $projectOrderTask): self
  852.     {
  853.         if (!$this->project_order_tasks->contains($projectOrderTask)) {
  854.             $this->project_order_tasks[] = $projectOrderTask;
  855.             $projectOrderTask->setResponsiblePerson($this);
  856.         }
  858.         return $this;
  859.     }
  861.     public function removeProjectOrderTask(ProjectOrderTasks $projectOrderTask): self
  862.     {
  863.         if ($this->project_order_tasks->removeElement($projectOrderTask)) {
  864.             // set the owning side to null (unless already changed)
  865.             if ($projectOrderTask->getResponsiblePerson() === $this) {
  866.                 $projectOrderTask->setResponsiblePerson(null);
  867.             }
  868.         }
  870.         return $this;
  871.     }
  873.     /**
  874.      * @return Collection<int, ProjectOrderTaskFulfillment>
  875.      */
  876.     public function getProjectOrderTaskFulfillments(): Collection
  877.     {
  878.         return $this->project_order_task_fulfillments;
  879.     }
  881.     public function addProjectOrderTaskFulfillment(ProjectOrderTaskFulfillment $projectOrderTaskFulfillment): self
  882.     {
  883.         if (!$this->project_order_task_fulfillments->contains($projectOrderTaskFulfillment)) {
  884.             $this->project_order_task_fulfillments[] = $projectOrderTaskFulfillment;
  885.             $projectOrderTaskFulfillment->setBranchContactPerson($this);
  886.         }
  888.         return $this;
  889.     }
  891.     public function removeProjectOrderTaskFulfillment(ProjectOrderTaskFulfillment $projectOrderTaskFulfillment): self
  892.     {
  893.         if ($this->project_order_task_fulfillments->removeElement($projectOrderTaskFulfillment)) {
  894.             // set the owning side to null (unless already changed)
  895.             if ($projectOrderTaskFulfillment->getBranchContactPerson() === $this) {
  896.                 $projectOrderTaskFulfillment->setBranchContactPerson(null);
  897.             }
  898.         }
  900.         return $this;
  901.     }
  904.     /** @return Collection|WorkerActivityLeaveEntitlement[] */
  905.     public function getLeaveEntitlements(): Collection
  906.     {
  907.         return $this->leave_entitlements;
  908.     }
  910.     public function addLeaveEntitlement(WorkerActivityLeaveEntitlement $entitlement): self
  911.     {
  912.         if (!$this->leave_entitlements->contains($entitlement)) {
  913.             $this->leave_entitlements[] = $entitlement;
  914.             $entitlement->setWorkerActivity($this);
  915.         }
  917.         return $this;
  918.     }
  919. }