src/Entity/Qualification.php line 15

Open in your IDE?
  1. <?php
  2. namespace App\Entity;
  3. use App\Repository\QualificationRepository;
  4. use Doctrine\Common\Collections\ArrayCollection;
  5. use Doctrine\Common\Collections\Collection;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use Symfony\Component\Serializer\Annotation\MaxDepth;
  8. use Symfony\Component\Serializer\Annotation\Groups;
  9. /**
  10.  * @ORM\Entity(repositoryClass=QualificationRepository::class)
  11.  */
  12. class Qualification
  13. {
  14.     /**
  15.      * @ORM\Id
  16.      * @ORM\GeneratedValue
  17.      * @ORM\Column(type="integer")
  18.      * @Groups({
  19.      *     "qualifications.base",
  20.      *     "project.qualifications",
  21.      *     "customer.joined.projects.depended.qualifications",
  22.      *     "stakeholder.selected.core.project.manage",
  23.      *     "worker.manage.base",
  24.      *     "worker.manage.selected.worker.in.project",
  25.      *     "worker.manage.joined.projects",
  26.      *     "selected.customer.project.for.worker",
  27.      *
  28.      * })
  29.      */
  30.     private $id;
  31.     /**
  32.      * @ORM\Column(type="string", length=255)
  33.      * @Groups({
  34.      *     "qualifications.base",
  35.      *     "project.qualifications",
  36.      *     "customer.joined.projects.depended.qualifications",
  37.      *     "stakeholder.selected.core.project.manage",
  38.      *     "worker.manage.base",
  39.      *     "worker.manage.selected.worker.in.project",
  40.      *     "worker.manage.joined.projects",
  41.      *     "selected.customer.project.for.worker"
  42.      * })
  43.      */
  44.     private $name;
  45.     /**
  46.      * @ORM\ManyToMany(targetEntity=Worker::class, mappedBy="qualifications")
  47.      */
  48.     private $workers;
  49.     /**
  50.      * @ORM\Column(type="string", length=255, nullable=true )
  51.      * @Groups({
  52.      *     "qualifications.base",
  53.      *     "project.qualifications",
  54.      *     "customer.joined.projects.depended.qualifications",
  55.      *     "stakeholder.selected.core.project.manage",
  56.      *     "worker.manage.selected.worker.in.project",
  57.      *     "worker.manage.joined.projects"
  58.      * })
  59.      */
  60.     private $color;
  61.     /**
  62.      * @ORM\ManyToMany(targetEntity=ProjectStakeholders::class, mappedBy="dependent_qualifications", cascade={"remove"} )
  63.      */
  64.     private $projectStakeholders;
  65.     /**
  66.      * @ORM\ManyToMany(targetEntity=WorkerInProject::class, mappedBy="assigned_qualifications")
  67.      */
  68.     private $workerInProjects;
  69.     /**
  70.      * @ORM\ManyToMany(targetEntity=Projects::class, mappedBy="dependent_qualifications")
  71.      */
  72.     private $projects;
  73.     /**
  74.      * @ORM\OneToMany(targetEntity=AccessAddTimesheetTime::class, mappedBy="qualification")
  75.      */
  76.     private $accessAddTimesheetTimes;
  77.     public function __construct()
  78.     {
  79.         $this->workers = new ArrayCollection();
  80.         $this->projectStakeholders = new ArrayCollection();
  81.         $this->workerInProjects = new ArrayCollection();
  82.         $this->projects = new ArrayCollection();
  83.         $this->accessAddTimesheetTimes = new ArrayCollection();
  84.     }
  85.     public function getId(): ?int
  86.     {
  87.         return $this->id;
  88.     }
  89.     public function getName(): ?string
  90.     {
  91.         return $this->name;
  92.     }
  93.     public function setName(string $name): self
  94.     {
  95.         $this->name $name;
  96.         return $this;
  97.     }
  98. //    /**
  99. //     * @return Collection<int, Worker>
  100. //     */
  101. //    public function getWorkers(): ?Collection
  102. //    {
  103. //        return $this->workers;
  104. //    }
  105.     public function addWorker(Worker $worker): self
  106.     {
  107.         if (!$this->workers->contains($worker)) {
  108.             $this->workers[] = $worker;
  109.             $worker->addQualification($this);
  110.         }
  111.         return $this;
  112.     }
  113.     public function removeWorker(Worker $worker): self
  114.     {
  115.         if ($this->workers->removeElement($worker)) {
  116.             $worker->removeQualification($this);
  117.         }
  118.         return $this;
  119.     }
  120.     public function getColor(): ?string
  121.     {
  122.         return $this->color;
  123.     }
  124.     public function setColor(string $color): self
  125.     {
  126.         $this->color $color;
  127.         return $this;
  128.     }
  129. //    /**
  130. //     * @return Collection<int, ProjectStakeholders>
  131. //     */
  132. //    public function getProjectStakeholders(): Collection
  133. //    {
  134. //
  135. ////        return $this->projectStakeholders->map(function(/**@var $projectStakeholder ProjectStakeholders*/$projectStakeholder){
  136. ////            return [
  137. ////                'id' => $projectStakeholder->getId(),
  138. ////                $projectStakeholder->getCreatedAt(),
  139. ////                $projectStakeholder->get(),
  140. ////            ]
  141. ////        });
  142. ////
  143. ////        return $this->projectStakeholders;
  144. //        return $this->projectStakeholders;
  145. //    }
  146.     public function addProjectStakeholder(ProjectStakeholders $projectStakeholder): self
  147.     {
  148.         if (!$this->projectStakeholders->contains($projectStakeholder)) {
  149.             $this->projectStakeholders[] = $projectStakeholder;
  150.             $projectStakeholder->addDependentQualification($this);
  151.         }
  152.         return $this;
  153.     }
  154.     public function removeProjectStakeholder(ProjectStakeholders $projectStakeholder): self
  155.     {
  156.         if ($this->projectStakeholders->removeElement($projectStakeholder)) {
  157.             $projectStakeholder->removeDependentQualification($this);
  158.         }
  159.         return $this;
  160.     }
  161. //    /**
  162. //     * @return Collection<int, WorkerInProject>
  163. //     */
  164. //    public function getWorkerInProjects(): Collection
  165. //    {
  166. //        return $this->workerInProjects;
  167. //
  168. //        return $this->workerInProjects->map( function(/**@var $workerInProject WorkerInProject*/ $workerInProject ){
  169. //            return [
  170. //                "id"=>$workerInProject->getId(),
  171. //                'project'=>[
  172. //                    "name"=>$workerInProject->getProject()->getProject()->getName(),
  173. //                ]
  174. //            ];
  175. //        });
  176. //
  177. //        // return new ArrayCollection([]); // $this->workerInProjects;
  178. //    }
  179.     public function addWorkerInProject(WorkerInProject $workerInProject): self
  180.     {
  181.         if (!$this->workerInProjects->contains($workerInProject)) {
  182.             $this->workerInProjects[] = $workerInProject;
  183.             $workerInProject->addAssignedQualification($this);
  184.         }
  185.         return $this;
  186.     }
  187.     public function removeWorkerInProject(WorkerInProject $workerInProject): self
  188.     {
  189.         if ($this->workerInProjects->removeElement($workerInProject)) {
  190.             $workerInProject->removeAssignedQualification($this);
  191.         }
  192.         return $this;
  193.     }
  194. //    /**
  195. //     * @return Collection<int, Projects>
  196. //     */
  197. //    public function getProjects(): Collection
  198. //    {
  199. //        return $this->projects;
  200. //        return $this->projects->map( function(/**@var $project Projects*/$project){
  201. //            return [
  202. //                "id"=>$project->getId(),
  203. //                'name'=>$project->getName()
  204. //            ];
  205. //        });
  206. //
  207. //        // return new ArrayCollection([]); // $this->projects;
  208. //    }
  209.     public function addProject(Projects $project): self
  210.     {
  211.         if (!$this->projects->contains($project)) {
  212.             $this->projects[] = $project;
  213.             $project->addDependentQualification($this);
  214.         }
  215.         return $this;
  216.     }
  217.     public function removeProject(Projects $project): self
  218.     {
  219.         if ($this->projects->removeElement($project)) {
  220.             $project->removeDependentQualification($this);
  221.         }
  222.         return $this;
  223.     }
  224.     /**
  225.      * @return Collection<int, AccessAddTimesheetTime>
  226.      */
  227.     public function getAccessAddTimesheetTimes(): Collection
  228.     {
  229.         return $this->accessAddTimesheetTimes;
  230.     }
  231.     public function addAccessAddTimesheetTime(AccessAddTimesheetTime $accessAddTimesheetTime): self
  232.     {
  233.         if (!$this->accessAddTimesheetTimes->contains($accessAddTimesheetTime)) {
  234.             $this->accessAddTimesheetTimes[] = $accessAddTimesheetTime;
  235.             $accessAddTimesheetTime->setQualification($this);
  236.         }
  237.         return $this;
  238.     }
  239.     public function removeAccessAddTimesheetTime(AccessAddTimesheetTime $accessAddTimesheetTime): self
  240.     {
  241.         if ($this->accessAddTimesheetTimes->removeElement($accessAddTimesheetTime)) {
  242.             // set the owning side to null (unless already changed)
  243.             if ($accessAddTimesheetTime->getQualification() === $this) {
  244.                 $accessAddTimesheetTime->setQualification(null);
  245.             }
  246.         }
  247.         return $this;
  248.     }
  249. }