src/Entity/FichePreserie.php line 11

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\FichePreserieRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Entity(repositoryClass: FichePreserieRepository::class)]
  11. class FichePreserie implements \Stringable
  12. {
  13.     #[ORM\Id]
  14.     #[ORM\GeneratedValue]
  15.     #[ORM\Column(type: 'integer')]
  16.     private $id;
  18.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  19.     private $reference;
  21.     #[ORM\ManyToOne(targetEntity: CategorieMetier::class, inversedBy: 'fichePreseries')]
  22.     private $categorie;
  24.     #[ORM\ManyToOne(targetEntity: SouscategorieMetier::class, inversedBy: 'fichePreseries')]
  25.     private $souscategorie;
  27.     #[ORM\Column(type: 'integer', nullable: true)]
  28.     private $version;
  30.     #[ORM\Column(type: 'datetime', nullable: true)]
  31.     private $date_creation;
  33.     #[ORM\Column(type: 'datetime', nullable: true)]
  34.     private $date_update;
  36.     #[ORM\OneToMany(targetEntity: FicheControlePreserie::class, mappedBy: 'fichepreserie')]
  37.     private $ficheControlePreseries;
  39.     #[ORM\ManyToOne(targetEntity: Atelier::class, inversedBy: 'fichePreseries')]
  40.     private $atelier;
  42.     #[ORM\Column(type: 'boolean', nullable: true)]
  43.     private int $cotraitance = 0;
  45.     #[ORM\OneToMany(targetEntity: FichePreserieOperation::class, mappedBy: 'fichepreserie', cascade: ['persist', 'remove'])]
  46.     private $operations;
  48.     #[ORM\OneToMany(targetEntity: FichePreserieCoupe::class, mappedBy: 'preserie', cascade: ['persist', 'remove'])]
  49.     private $fichePreserieCoupes;
  51.     #[ORM\OneToMany(targetEntity: FicheQualite::class, mappedBy: 'fichepreserie', cascade: ['persist', 'remove'])]
  52.     private $ficheQualites;
  54.     #[ORM\OneToMany(targetEntity: FicheQualiteAtelierAuditeur::class, mappedBy: 'fichepreserie', cascade: ['persist', 'remove'])]
  55.     private $ficheQualiteAtelierAuditeurs;
  57.     #[ORM\OneToMany(targetEntity: FicheQualiteSynthese::class, mappedBy: 'fiche_preserie', cascade: ['persist', 'remove'])]
  58.     private $ficheQualiteSyntheses;
  60.     #[ORM\OneToMany(targetEntity: FicheQualiteAtelier::class, mappedBy: 'fichepreserie', cascade: ['persist', 'remove'])]
  61.     private $ficheQualiteAteliers;
  63.     #[ORM\OneToMany(targetEntity: FicheQualiteCent::class, mappedBy: 'fichepreserie', cascade: ['persist', 'remove'])]
  64.     private $ficheQualiteCents;
  66.     public function __construct()
  67.     {
  68.         $this->date_creation = new \DateTime();
  69.         $this->date_update = new \DateTime();
  70.         $this->ficheControlePreseries = new ArrayCollection();
  71.         $this->operations = new ArrayCollection();
  72.         $this->fichePreserieCoupes = new ArrayCollection();
  73.         $this->ficheQualites = new ArrayCollection();
  74.         $this->ficheQualiteAtelierAuditeurs = new ArrayCollection();
  75.         $this->ficheQualiteSyntheses = new ArrayCollection();
  76.         $this->ficheQualiteAteliers = new ArrayCollection();
  77.         $this->ficheQualiteCents = new ArrayCollection();
  78.     }
  79.     public function __clone()
  80.     {
  81.        if ($this->id) {
  82.             $this->id = null;
  83.                                                                                     
  85.             $operationsCloneCollection = new ArrayCollection();                   
  86.             foreach ($this->operations as $operation) {                             
  87.                 $operationClone = clone $operation; 
  88.                 $operationClone->setFichepreserie($this);                             
  89.                 $operationsCloneCollection->add($operationClone);                   
  90.             }                                                               
  91.             $this->operations = $operationsCloneCollection; 
  92.             return $this;
  93.         }
  94.     }
  96.     public function getId(): ?int
  97.     {
  98.         return $this->id;
  99.     }
  101.     public function getReference(): ?string
  102.     {
  103.         return $this->reference;
  104.     }
  106.     public function setReference(?string $reference): self
  107.     {
  108.         $this->reference = $reference;
  110.         return $this;
  111.     }
  113.     public function getCategorie(): ?CategorieMetier
  114.     {
  115.         return $this->categorie;
  116.     }
  118.     public function setCategorie(?CategorieMetier $categorie): self
  119.     {
  120.         $this->categorie = $categorie;
  122.         return $this;
  123.     }
  125.     public function getSouscategorie(): ?SouscategorieMetier
  126.     {
  127.         return $this->souscategorie;
  128.     }
  130.     public function setSouscategorie(?SouscategorieMetier $souscategorie): self
  131.     {
  132.         $this->souscategorie = $souscategorie;
  134.         return $this;
  135.     }
  137.     public function getVersion(): ?int
  138.     {
  139.         return $this->version;
  140.     }
  142.     public function setVersion(?int $version): self
  143.     {
  144.         $this->version = $version;
  146.         return $this;
  147.     }
  149.     public function getDateCreation(): ?\DateTimeInterface
  150.     {
  151.         return $this->date_creation;
  152.     }
  154.     public function setDateCreation(?\DateTimeInterface $date_creation): self
  155.     {
  156.         $this->date_creation = $date_creation;
  158.         return $this;
  159.     }
  161.     public function getDateUpdate(): ?\DateTimeInterface
  162.     {
  163.         return $this->date_update;
  164.     }
  166.     public function setDateUpdate(?\DateTimeInterface $date_update): self
  167.     {
  168.         $this->date_update = $date_update;
  170.         return $this;
  171.     }
  173.     /**
  174.      * @return Collection|FicheControlePreserie[]
  175.      */
  176.     public function getFicheControlePreseries(): Collection
  177.     {
  178.         return $this->ficheControlePreseries;
  179.     }
  181.     public function addFicheControlePreseries(FicheControlePreserie $ficheControlePreseries): self
  182.     {
  183.         if (!$this->ficheControlePreseries->contains($ficheControlePreseries)) {
  184.             $this->ficheControlePreseries[] = $ficheControlePreseries;
  185.             $ficheControlePreseries->setFichepreserie($this);
  186.         }
  188.         return $this;
  189.     }
  191.     public function removeFicheControlePreseries(FicheControlePreserie $ficheControlePreseries): self
  192.     {
  193.         if ($this->ficheControlePreseries->removeElement($ficheControlePreseries)) {
  194.             // set the owning side to null (unless already changed)
  195.             if ($ficheControlePreseries->getFichepreserie() === $this) {
  196.                 $ficheControlePreseries->setFichepreserie(null);
  197.             }
  198.         }
  200.         return $this;
  201.     }
  203.     public function getAtelier(): ?Atelier
  204.     {
  205.         return $this->atelier;
  206.     }
  208.     public function setAtelier(?Atelier $atelier): self
  209.     {
  210.         $this->atelier = $atelier;
  212.         return $this;
  213.     }
  215.     public function getCotraitance(): ?bool
  216.     {
  217.         return $this->cotraitance;
  218.     }
  220.     public function setCotraitance(?bool $cotraitance): self
  221.     {
  222.         $this->cotraitance = $cotraitance;
  224.         return $this;
  225.     }
  227.     /**
  228.      * @return Collection|FichePreserieOperation[]
  229.      */
  230.     public function getOperations(): Collection
  231.     {
  232.         return $this->operations;
  233.     }
  235.     public function addOperation(FichePreserieOperation $fichePreserieOperation): self
  236.     {
  237.         if (!$this->operations->contains($fichePreserieOperation)) {
  238.             $this->operations[] = $fichePreserieOperation;
  239.             $fichePreserieOperation->setFichepreserie($this);
  240.         }
  242.         return $this;
  243.     }
  245.     public function removeOperation(FichePreserieOperation $fichePreserieOperation): self
  246.     {
  247.         if ($this->operations->removeElement($fichePreserieOperation)) {
  248.             // set the owning side to null (unless already changed)
  249.             if ($fichePreserieOperation->getFichepreserie() === $this) {
  250.                 $fichePreserieOperation->setFichepreserie(null);
  251.             }
  252.         }
  254.         return $this;
  255.     }
  257.     /**
  258.      * @return Collection|FichePreserieCoupe[]
  259.      */
  260.     public function getFichePreserieCoupes(): Collection
  261.     {
  262.         return $this->fichePreserieCoupes;
  263.     }
  265.     public function addFichePreserieCoupe(FichePreserieCoupe $fichePreserieCoupe): self
  266.     {
  267.         if (!$this->fichePreserieCoupes->contains($fichePreserieCoupe)) {
  268.             $this->fichePreserieCoupes[] = $fichePreserieCoupe;
  269.             $fichePreserieCoupe->setPreserie($this);
  270.         }
  272.         return $this;
  273.     }
  275.     public function removeFichePreserieCoupe(FichePreserieCoupe $fichePreserieCoupe): self
  276.     {
  277.         if ($this->fichePreserieCoupes->removeElement($fichePreserieCoupe)) {
  278.             // set the owning side to null (unless already changed)
  279.             if ($fichePreserieCoupe->getPreserie() === $this) {
  280.                 $fichePreserieCoupe->setPreserie(null);
  281.             }
  282.         }
  284.         return $this;
  285.     }
  286.     public function __toString(): string
  287.     {
  288.         return (string) $this->reference;
  289.     }
  291.     /**
  292.      * @return Collection|FicheQualite[]
  293.      */
  294.     public function getFicheQualites(): Collection
  295.     {
  296.         return $this->ficheQualites;
  297.     }
  299.     public function addFicheQualite(FicheQualite $ficheQualite): self
  300.     {
  301.         if (!$this->ficheQualites->contains($ficheQualite)) {
  302.             $this->ficheQualites[] = $ficheQualite;
  303.             $ficheQualite->setFichepreserie($this);
  304.         }
  306.         return $this;
  307.     }
  309.     public function removeFicheQualite(FicheQualite $ficheQualite): self
  310.     {
  311.         if ($this->ficheQualites->removeElement($ficheQualite)) {
  312.             // set the owning side to null (unless already changed)
  313.             if ($ficheQualite->getFichepreserie() === $this) {
  314.                 $ficheQualite->setFichepreserie(null);
  315.             }
  316.         }
  318.         return $this;
  319.     }
  321.     /**
  322.      * @return Collection|FicheQualiteAtelierAuditeur[]
  323.      */
  324.     public function getFicheQualiteAtelierAuditeurs(): Collection
  325.     {
  326.         return $this->ficheQualiteAtelierAuditeurs;
  327.     }
  329.     public function addFicheQualiteAtelierAuditeur(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeur): self
  330.     {
  331.         if (!$this->ficheQualiteAtelierAuditeurs->contains($ficheQualiteAtelierAuditeur)) {
  332.             $this->ficheQualiteAtelierAuditeurs[] = $ficheQualiteAtelierAuditeur;
  333.             $ficheQualiteAtelierAuditeur->setFichepreserie($this);
  334.         }
  336.         return $this;
  337.     }
  339.     public function removeFicheQualiteAtelierAuditeur(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeur): self
  340.     {
  341.         if ($this->ficheQualiteAtelierAuditeurs->removeElement($ficheQualiteAtelierAuditeur)) {
  342.             // set the owning side to null (unless already changed)
  343.             if ($ficheQualiteAtelierAuditeur->getFichepreserie() === $this) {
  344.                 $ficheQualiteAtelierAuditeur->setFichepreserie(null);
  345.             }
  346.         }
  348.         return $this;
  349.     }
  351.     /**
  352.      * @return Collection|FicheQualiteSynthese[]
  353.      */
  354.     public function getFicheQualiteSyntheses(): Collection
  355.     {
  356.         return $this->ficheQualiteSyntheses;
  357.     }
  359.     public function addFicheQualiteSynthesis(FicheQualiteSynthese $ficheQualiteSynthesis): self
  360.     {
  361.         if (!$this->ficheQualiteSyntheses->contains($ficheQualiteSynthesis)) {
  362.             $this->ficheQualiteSyntheses[] = $ficheQualiteSynthesis;
  363.             $ficheQualiteSynthesis->setFichePreserie($this);
  364.         }
  366.         return $this;
  367.     }
  369.     public function removeFicheQualiteSynthesis(FicheQualiteSynthese $ficheQualiteSynthesis): self
  370.     {
  371.         if ($this->ficheQualiteSyntheses->removeElement($ficheQualiteSynthesis)) {
  372.             // set the owning side to null (unless already changed)
  373.             if ($ficheQualiteSynthesis->getFichePreserie() === $this) {
  374.                 $ficheQualiteSynthesis->setFichePreserie(null);
  375.             }
  376.         }
  378.         return $this;
  379.     }
  381.     /**
  382.      * @return Collection|FicheQualiteAtelier[]
  383.      */
  384.     public function getFicheQualiteAteliers(): Collection
  385.     {
  386.         return $this->ficheQualiteAteliers;
  387.     }
  389.     public function addFicheQualiteAtelier(FicheQualiteAtelier $ficheQualiteAtelier): self
  390.     {
  391.         if (!$this->ficheQualiteAteliers->contains($ficheQualiteAtelier)) {
  392.             $this->ficheQualiteAteliers[] = $ficheQualiteAtelier;
  393.             $ficheQualiteAtelier->setFichepreserie($this);
  394.         }
  396.         return $this;
  397.     }
  399.     public function removeFicheQualiteAtelier(FicheQualiteAtelier $ficheQualiteAtelier): self
  400.     {
  401.         if ($this->ficheQualiteAteliers->removeElement($ficheQualiteAtelier)) {
  402.             // set the owning side to null (unless already changed)
  403.             if ($ficheQualiteAtelier->getFichepreserie() === $this) {
  404.                 $ficheQualiteAtelier->setFichepreserie(null);
  405.             }
  406.         }
  408.         return $this;
  409.     }
  411.     /**
  412.      * @return Collection|FicheQualiteCent[]
  413.      */
  414.     public function getFicheQualiteCents(): Collection
  415.     {
  416.         return $this->ficheQualiteCents;
  417.     }
  419.     public function addFicheQualiteCent(FicheQualiteCent $ficheQualiteCent): self
  420.     {
  421.         if (!$this->ficheQualiteCents->contains($ficheQualiteCent)) {
  422.             $this->ficheQualiteCents[] = $ficheQualiteCent;
  423.             $ficheQualiteCent->setFichepreserie($this);
  424.         }
  426.         return $this;
  427.     }
  429.     public function removeFicheQualiteCent(FicheQualiteCent $ficheQualiteCent): self
  430.     {
  431.         if ($this->ficheQualiteCents->removeElement($ficheQualiteCent)) {
  432.             // set the owning side to null (unless already changed)
  433.             if ($ficheQualiteCent->getFichepreserie() === $this) {
  434.                 $ficheQualiteCent->setFichepreserie(null);
  435.             }
  436.         }
  438.         return $this;
  439.     }
  440. }