src/Entity/Certificates.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\CertificatesRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Component\Serializer\Annotation\Groups;
  11. /**
  12.  * @ORM\Entity(repositoryClass=CertificatesRepository::class)
  13.  */
  14. class Certificates
  15. {
  16.     /**
  17.      * @ORM\Id
  18.      * @ORM\GeneratedValue
  19.      * @ORM\Column(type="integer")
  20.      * @Groups({
  21.      *     "certificates.base",
  22.      *     "customer.certificate.manage",
  23.      *     "customer.manage.base",
  24.      *     "project.certificates",
  25.      *     "customer.joined.projects.depended.certificates",
  26.      *     "stakeholder.selected.core.project.manage",
  27.      *     "worker.manage.base",
  28.      *     "worker.certificate.manage",
  29.      *     "selected.customer.project.for.worker"
  30.      * })
  31.      */
  32.     private $id;
  34.     /**
  35.      * @ORM\Column(type="string", length=255)
  36.      * @Groups({
  37.      *     "certificates.base",
  38.      *     "customer.certificate.manage",
  39.      *     "customer.manage.base",
  40.      *     "project.certificates",
  41.      *     "customer.joined.projects.depended.certificates",
  42.      *     "stakeholder.selected.core.project.manage",
  43.      *     "worker.manage.base",
  44.      *     "worker.certificate.manage",
  45.      *     "selected.customer.project.for.worker"
  46.      * })
  47.      */
  48.     private $name;
  50.     /**
  51.      * @ORM\Column(type="string", length=255)
  52.      * @Groups({
  53.      *     "certificates.base",
  54.      *     "customer.manage.base",
  55.      *     "project.certificates",
  56.      *     "customer.joined.projects.depended.certificates",
  57.      *     "stakeholder.selected.core.project.manage",
  58.      *     "worker.manage.base",
  59.      *     "worker.certificate.manage",
  60.      *     "selected.customer.project.for.worker"
  61.      * })
  62.      */
  63.     private $color;
  65.     /**
  66.      * @ORM\OneToMany(targetEntity=WorkerCertificates::class, mappedBy="certificate")
  67.      */
  68.     private $workerCertificates;
  70.     /**
  71.      * @ORM\ManyToOne(targetEntity=CertificatesGroups::class, inversedBy="certificates")
  72.      * @ORM\JoinColumn(nullable=false)
  73.      * @Groups({
  74.      *        "certificate.group.base",
  75.      *    })
  76.      */
  77.     private $groups;
  79.     /**
  80.      * @ORM\OneToMany(targetEntity=CustomerCertificates::class, mappedBy="certificate")
  81.      */
  82.     private $customerCertificates;
  84.     /**
  85.      * @ORM\ManyToMany(targetEntity=ProjectStakeholders::class, mappedBy="dependent_certificates")
  86.      */
  87.     private $projectStakeholders;
  89.     /**
  90.      * @ORM\ManyToMany(targetEntity=Projects::class, mappedBy="dependent_certificates")
  91.      */
  92.     private $projects;
  94.     /**
  95.      * @ORM\ManyToOne(targetEntity=CertificateEligibilities::class, inversedBy="certificates")
  96.      * @Groups({"certificates.base", "project.certificates", "customer.joined.projects.depended.certificates.eligibility"})
  97.      */
  98.     private $certificate_eligibility;
  100.     public function __construct()
  101.     {
  102.         $this->workerCertificates = new ArrayCollection();
  103.         $this->customerCertificates = new ArrayCollection();
  104.         $this->projectStakeholders = new ArrayCollection();
  105.         $this->projects = new ArrayCollection();
  106.     }
  108.     public function getId(): ?int
  109.     {
  110.         return $this->id;
  111.     }
  113.     public function getName(): ?string
  114.     {
  115.         return $this->name;
  116.     }
  118.     public function setName(string $name): self
  119.     {
  120.         $this->name = $name;
  122.         return $this;
  123.     }
  125.     public function getColor(): ?string
  126.     {
  127.         return $this->color;
  128.     }
  130.     public function setColor(string $color): self
  131.     {
  132.         $this->color = $color;
  134.         return $this;
  135.     }
  137.     /**
  138.      * @return Collection<int, WorkerCertificates>
  139.      */
  140. //    public function getWorkerCertificates(): Collection
  141. //    {
  142. //        return $this->workerCertificates;
  143. //    }
  145.     public function addWorkerCertificate(WorkerCertificates $workerCertificate): self
  146.     {
  147.         if (!$this->workerCertificates->contains($workerCertificate)) {
  148.             $this->workerCertificates[] = $workerCertificate;
  149.             $workerCertificate->setCertificate($this);
  150.         }
  152.         return $this;
  153.     }
  155.     public function removeWorkerCertificate(WorkerCertificates $workerCertificate): self
  156.     {
  157.         if ($this->workerCertificates->removeElement($workerCertificate)) {
  158.             // set the owning side to null (unless already changed)
  159.             if ($workerCertificate->getCertificate() === $this) {
  160.                 $workerCertificate->setCertificate(null);
  161.             }
  162.         }
  164.         return $this;
  165.     }
  167. //    public function getGroups(): ?CertificatesGroups
  168. //    {
  169. //        return $this->groups;
  170. //    }
  172.     public function setGroups(?CertificatesGroups $groups): self
  173.     {
  174.         $this->groups = $groups;
  176.         return $this;
  177.     }
  179.     /**
  180.      * @return Collection<int, CustomerCertificates>
  181.      */
  182. //    public function getCustomerCertificates(): Collection
  183. //    {
  184. //        return $this->customerCertificates;
  185. //    }
  187.     public function addCustomerCertificate(CustomerCertificates $customerCertificate): self
  188.     {
  189.         if (!$this->customerCertificates->contains($customerCertificate)) {
  190.             $this->customerCertificates[] = $customerCertificate;
  191.             $customerCertificate->setCertificate($this);
  192.         }
  194.         return $this;
  195.     }
  197.     public function removeCustomerCertificate(CustomerCertificates $customerCertificate): self
  198.     {
  199.         if ($this->customerCertificates->removeElement($customerCertificate)) {
  200.             // set the owning side to null (unless already changed)
  201.             if ($customerCertificate->getCertificate() === $this) {
  202.                 $customerCertificate->setCertificate(null);
  203.             }
  204.         }
  206.         return $this;
  207.     }
  209.     /**
  210.      * @return Collection<int, ProjectStakeholders>
  211.      */
  212. //    public function getProjectStakeholders(): Collection
  213. //    {
  214. //        return $this->projectStakeholders;
  215. //    }
  217.     public function addProjectStakeholder(ProjectStakeholders $projectStakeholder): self
  218.     {
  219.         if (!$this->projectStakeholders->contains($projectStakeholder)) {
  220.             $this->projectStakeholders[] = $projectStakeholder;
  221.             $projectStakeholder->addDependentCertificate($this);
  222.         }
  224.         return $this;
  225.     }
  227.     public function removeProjectStakeholder(ProjectStakeholders $projectStakeholder): self
  228.     {
  229.         if ($this->projectStakeholders->removeElement($projectStakeholder)) {
  230.             $projectStakeholder->removeDependentCertificate($this);
  231.         }
  233.         return $this;
  234.     }
  236.     /**
  237.      * @return Collection<int, Projects>
  238.      */
  239. //    public function getProjects(): Collection
  240. //    {
  241. //        return $this->projects;
  242. //    }
  244.     public function addProject(Projects $project): self
  245.     {
  246.         if (!$this->projects->contains($project)) {
  247.             $this->projects[] = $project;
  248.             $project->addDependentCertificate($this);
  249.         }
  251.         return $this;
  252.     }
  254.     public function removeProject(Projects $project): self
  255.     {
  256.         if ($this->projects->removeElement($project)) {
  257.             $project->removeDependentCertificate($this);
  258.         }
  260.         return $this;
  261.     }
  263.     public function getCertificateEligibility(): ?CertificateEligibilities
  264.     {
  265.         return $this->certificate_eligibility;
  266.     }
  268.     public function setCertificateEligibility(?CertificateEligibilities $certificate_eligibility): self
  269.     {
  270.         $this->certificate_eligibility = $certificate_eligibility;
  272.         return $this;
  273.     }
  274. }