src/Entity/InvoiceType.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\InvoiceTypeRepository;
  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=InvoiceTypeRepository::class)
  13.  */
  14. class InvoiceType
  15. {
  16.     /**
  17.      * @ORM\Id
  18.      * @ORM\GeneratedValue
  19.      * @ORM\Column(type="integer")
  20.      * @Groups({
  21.      *     "invoice.type.base",
  22.      *     "project.details",
  23.      *     "project.details.orders",
  24.      *     "order.detail",
  25.      *
  26.      *     "invoice_type@core",
  27.      *     "invoice_type@base"
  28.      * })
  29.      */ 
  30.     private $id;
  31.     
  32.     /**
  33.      * @ORM\Column(type="string", length=64, unique=true)
  34.      * @Groups({
  35.      *      "invoice.type.base",
  36.      *      "project.details",
  37.      *      "project.details.orders",
  38.      *      "order.detail",
  39.      *
  40.      *      "invoice_type@core",
  41.      *      "invoice_type@base"
  42.      * })
  43.      */
  44.     private $name;
  45.     
  47.     /**
  48.      * @ORM\Column(type="string", length=255)
  49.      */
  50.     private $description;
  52.     /**
  53.      * @ORM\OneToMany(targetEntity=ProjectOrders::class, mappedBy="invoice_type")
  54.      */
  55.     private $projectOrders;
  57.     /**
  58.      * @ORM\OneToMany(targetEntity=Projects::class, mappedBy="invoice_type")
  59.      */
  60.     private $projects;
  62.     /**
  63.      * @ORM\OneToMany(targetEntity=Invoices::class, mappedBy="invoice_type")
  64.      */
  65.     private $invoices;
  67.     /**
  68.      * @ORM\Column(type="string", length=32, nullable=true)
  69.      * @Groups({
  70.      *     "invoice_type@core",
  71.      *     "invoice_type@base"
  72.      * })
  73.      */
  74.     private $severity;
  77.     public function __construct()
  78.     {
  79.         $this->projectOrders = new ArrayCollection();
  80.         $this->projects = new ArrayCollection();
  81.         $this->invoices = new ArrayCollection();
  82.     }
  84.     public function getId(): ?int
  85.     {
  86.         return $this->id;
  87.     }
  89.     public function getName(): ?string
  90.     {
  91.         return $this->name;
  92.     }
  94.     public function setName(string $name): self
  95.     {
  96.         $this->name = $name;
  98.         return $this;
  99.     }
  101.     public function getDescription(): ?string
  102.     {
  103.         return $this->description;
  104.     }
  106.     public function setDescription(string $description): self
  107.     {
  108.         $this->description = $description;
  110.         return $this;
  111.     }
  113.     /**
  114.      * @return Collection<int, ProjectOrders>
  115.      */
  116.     public function getProjectOrders(): Collection
  117.     {
  118.         return $this->projectOrders;
  119.     }
  121.     public function addProjectOrder(ProjectOrders $projectOrder): self
  122.     {
  123.         if (!$this->projectOrders->contains($projectOrder)) {
  124.             $this->projectOrders[] = $projectOrder;
  125.             $projectOrder->setInvoiceType($this);
  126.         }
  128.         return $this;
  129.     }
  131.     public function removeProjectOrder(ProjectOrders $projectOrder): self
  132.     {
  133.         if ($this->projectOrders->removeElement($projectOrder)) {
  134.             // set the owning side to null (unless already changed)
  135.             if ($projectOrder->getInvoiceType() === $this) {
  136.                 $projectOrder->setInvoiceType(null);
  137.             }
  138.         }
  140.         return $this;
  141.     }
  143.     /**
  144.      * @return Collection<int, Projects>
  145.      */
  146.     public function getProjects(): Collection
  147.     {
  148.         return $this->projects;
  149.     }
  151.     public function addProject(Projects $project): self
  152.     {
  153.         if (!$this->projects->contains($project)) {
  154.             $this->projects[] = $project;
  155.             $project->setInvoiceType($this);
  156.         }
  158.         return $this;
  159.     }
  161.     public function removeProject(Projects $project): self
  162.     {
  163.         if ($this->projects->removeElement($project)) {
  164.             // set the owning side to null (unless already changed)
  165.             if ($project->getInvoiceType() === $this) {
  166.                 $project->setInvoiceType(null);
  167.             }
  168.         }
  170.         return $this;
  171.     }
  173.     /**
  174.      * @return Collection<int, Invoices>
  175.      */
  176.     public function getInvoices(): Collection
  177.     {
  178.         return $this->invoices;
  179.     }
  181.     public function addInvoice(Invoices $invoice): self
  182.     {
  183.         if (!$this->invoices->contains($invoice)) {
  184.             $this->invoices[] = $invoice;
  185.             $invoice->setInvoiceType($this);
  186.         }
  188.         return $this;
  189.     }
  191.     public function removeInvoice(Invoices $invoice): self
  192.     {
  193.         if ($this->invoices->removeElement($invoice)) {
  194.             // set the owning side to null (unless already changed)
  195.             if ($invoice->getInvoiceType() === $this) {
  196.                 $invoice->setInvoiceType(null);
  197.             }
  198.         }
  200.         return $this;
  201.     }
  203.     public function getSeverity(): ?string
  204.     {
  205.         return $this->severity;
  206.     }
  208.     public function setSeverity(?string $severity): self
  209.     {
  210.         $this->severity = $severity;
  212.         return $this;
  213.     }
  214. }