src/Entity/Atelier.php line 11

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\AtelierRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Entity(repositoryClass: AtelierRepository::class)]
  11. class Atelier 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 $name;
  21.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  22.     private $code_bu;
  24.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  25.     private $cout_horaire;
  27.     #[ORM\OneToMany(targetEntity: User::class, mappedBy: 'atelier')]
  28.     private $users;
  30.     #[ORM\OneToMany(targetEntity: Mailing::class, mappedBy: 'atelier')]
  31.     private $mailings;
  33.     #[ORM\OneToMany(targetEntity: Colisage::class, mappedBy: 'atelier')]
  34.     private $colisages;
  36.     #[ORM\OneToMany(targetEntity: FichePreserie::class, mappedBy: 'atelier')]
  37.     private $fichePreseries;
  39.     #[ORM\OneToMany(targetEntity: FicheControlePreserie::class, mappedBy: 'atelier')]
  40.     private $ficheControlePreseries;
  42.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  43.     private $code_magasin;
  45.     #[ORM\OneToMany(targetEntity: FicheQualite::class, mappedBy: 'atelier')]
  46.     private $ficheQualites;
  48.     #[ORM\OneToMany(targetEntity: FicheQualiteAtelierAuditeur::class, mappedBy: 'atelier')]
  49.     private $ficheQualiteAtelierAuditeurs;
  51.     #[ORM\OneToMany(targetEntity: FormulaireTeteCollection::class, mappedBy: 'atelier')]
  52.     private $formulaireTeteCollections;
  54.     #[ORM\OneToMany(targetEntity: FormulaireCollection::class, mappedBy: 'atelier')]
  55.     private $formulaireCollections;
  57.     #[ORM\OneToMany(targetEntity: FicheQualiteSynthese::class, mappedBy: 'atelier')]
  58.     private $ficheQualiteSyntheses;
  60.     #[ORM\OneToMany(targetEntity: FicheQualiteAtelier::class, mappedBy: 'atelier')]
  61.     private $ficheQualiteAteliers;
  63.     #[ORM\OneToMany(targetEntity: FicheQualiteCent::class, mappedBy: 'atelier')]
  64.     private $ficheQualiteCents;
  66.     #[ORM\OneToMany(targetEntity: FicheReparation::class, mappedBy: 'atelier')]
  67.     private $ficheReparations;
  69.     #[ORM\OneToMany(targetEntity: FicheControleEnCours::class, mappedBy: 'atelier')]
  70.     private $ficheControleEnCours;
  72.     #[ORM\OneToMany(targetEntity: AtelierChaine::class, mappedBy: 'atelier')]
  73.     private $atelierChaines;
  75.     #[ORM\Column(type: 'text', nullable: true)]
  76.     private $adresse;
  78.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  79.     private $code_postal;
  81.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  82.     private $pays;
  84.     #[ORM\Column(type: 'boolean', nullable: true)]
  85.     private $actif;
  87.     #[ORM\OneToMany(targetEntity: Lancement::class, mappedBy: 'atelier')]
  88.     private $lancements;
  90.     #[ORM\OneToMany(targetEntity: Derogation::class, mappedBy: 'atelier')]
  91.     private $derogations;
  93.     #[ORM\OneToMany(targetEntity: DerogationSynthese::class, mappedBy: 'atelier')]
  94.     private $derogationSyntheses;
  96.     #[ORM\OneToMany(targetEntity: FicheAvoir::class, mappedBy: 'atelier')]
  97.     private $ficheAvoirs;
  99.     #[ORM\Column(length: 255, nullable: true)]
  100.     private ?string $type = null;
  102.     #[ORM\OneToMany(mappedBy: 'atelier', targetEntity: MailIndicateurQualite::class)]
  103.     private Collection $mailIndicateurQualites;
  105.     public function __construct()
  106.     {
  107.         $this->users = new ArrayCollection();
  108.         $this->mailings = new ArrayCollection();
  109.         $this->colisages = new ArrayCollection();
  110.         $this->fichePreseries = new ArrayCollection();
  111.         $this->ficheControlePreseries = new ArrayCollection();
  112.         $this->ficheQualites = new ArrayCollection();
  113.         $this->ficheQualiteAtelierAuditeurs = new ArrayCollection();
  114.         $this->formulaireTeteCollections = new ArrayCollection();
  115.         $this->formulaireCollections = new ArrayCollection();
  116.         $this->ficheQualiteSyntheses = new ArrayCollection();
  117.         $this->ficheQualiteAteliers = new ArrayCollection();
  118.         $this->ficheQualiteCents = new ArrayCollection();
  119.         $this->ficheReparations = new ArrayCollection();
  120.         $this->ficheControleEnCours = new ArrayCollection();
  121.         $this->atelierChaines = new ArrayCollection();
  122.         $this->lancements = new ArrayCollection();
  123.         $this->derogations = new ArrayCollection();
  124.         $this->derogationSyntheses = new ArrayCollection();
  125.         $this->ficheAvoirs = new ArrayCollection();
  126.         $this->mailIndicateurQualites = new ArrayCollection();
  127.     }
  128.     public function __toString(): string
  129.     {
  130.         return (string) $this->name;
  131.     }
  133.     public function getId(): ?int
  134.     {
  135.         return $this->id;
  136.     }
  138.     public function getName(): ?string
  139.     {
  140.         return $this->name;
  141.     }
  143.     public function setName(?string $name): self
  144.     {
  145.         $this->name = $name;
  147.         return $this;
  148.     }
  150.     public function getCodeBu(): ?string
  151.     {
  152.         return $this->code_bu;
  153.     }
  155.     public function setCodeBu(?string $code_bu): self
  156.     {
  157.         $this->code_bu = $code_bu;
  159.         return $this;
  160.     }
  162.     public function getCoutHoraire(): ?string
  163.     {
  164.         return $this->cout_horaire;
  165.     }
  167.     public function setCoutHoraire(?string $cout_horaire): self
  168.     {
  169.         $this->cout_horaire = $cout_horaire;
  171.         return $this;
  172.     }
  174.     /**
  175.      * @return Collection|User[]
  176.      */
  177.     public function getUsers(): Collection
  178.     {
  179.         return $this->users;
  180.     }
  182.     public function addUser(User $user): self
  183.     {
  184.         if (!$this->users->contains($user)) {
  185.             $this->users[] = $user;
  186.             $user->setAtelier($this);
  187.         }
  189.         return $this;
  190.     }
  192.     public function removeUser(User $user): self
  193.     {
  194.         if ($this->users->removeElement($user)) {
  195.             // set the owning side to null (unless already changed)
  196.             if ($user->getAtelier() === $this) {
  197.                 $user->setAtelier(null);
  198.             }
  199.         }
  201.         return $this;
  202.     }
  204.     /**
  205.      * @return Collection|Mailing[]
  206.      */
  207.     public function getMailings(): Collection
  208.     {
  209.         return $this->mailings;
  210.     }
  212.     public function addMailing(Mailing $mailing): self
  213.     {
  214.         if (!$this->mailings->contains($mailing)) {
  215.             $this->mailings[] = $mailing;
  216.             $mailing->setAtelier($this);
  217.         }
  219.         return $this;
  220.     }
  222.     public function removeMailing(Mailing $mailing): self
  223.     {
  224.         if ($this->mailings->removeElement($mailing)) {
  225.             // set the owning side to null (unless already changed)
  226.             if ($mailing->getAtelier() === $this) {
  227.                 $mailing->setAtelier(null);
  228.             }
  229.         }
  231.         return $this;
  232.     }
  234.     /**
  235.      * @return Collection|Colisage[]
  236.      */
  237.     public function getColisages(): Collection
  238.     {
  239.         return $this->colisages;
  240.     }
  242.     public function addColisage(Colisage $colisage): self
  243.     {
  244.         if (!$this->colisages->contains($colisage)) {
  245.             $this->colisages[] = $colisage;
  246.             $colisage->setAtelier($this);
  247.         }
  249.         return $this;
  250.     }
  252.     public function removeColisage(Colisage $colisage): self
  253.     {
  254.         if ($this->colisages->removeElement($colisage)) {
  255.             // set the owning side to null (unless already changed)
  256.             if ($colisage->getAtelier() === $this) {
  257.                 $colisage->setAtelier(null);
  258.             }
  259.         }
  261.         return $this;
  262.     }
  264.     /**
  265.      * @return Collection|FichePreserie[]
  266.      */
  267.     public function getFichePreseries(): Collection
  268.     {
  269.         return $this->fichePreseries;
  270.     }
  272.     public function addFichePreseries(FichePreserie $fichePreseries): self
  273.     {
  274.         if (!$this->fichePreseries->contains($fichePreseries)) {
  275.             $this->fichePreseries[] = $fichePreseries;
  276.             $fichePreseries->setAtelier($this);
  277.         }
  279.         return $this;
  280.     }
  282.     public function removeFichePreseries(FichePreserie $fichePreseries): self
  283.     {
  284.         if ($this->fichePreseries->removeElement($fichePreseries)) {
  285.             // set the owning side to null (unless already changed)
  286.             if ($fichePreseries->getAtelier() === $this) {
  287.                 $fichePreseries->setAtelier(null);
  288.             }
  289.         }
  291.         return $this;
  292.     }
  294.     /**
  295.      * @return Collection|FicheControlePreserie[]
  296.      */
  297.     public function getFicheControlePreseries(): Collection
  298.     {
  299.         return $this->ficheControlePreseries;
  300.     }
  302.     public function addFicheControlePreseries(FicheControlePreserie $ficheControlePreseries): self
  303.     {
  304.         if (!$this->ficheControlePreseries->contains($ficheControlePreseries)) {
  305.             $this->ficheControlePreseries[] = $ficheControlePreseries;
  306.             $ficheControlePreseries->setAtelier($this);
  307.         }
  309.         return $this;
  310.     }
  312.     public function removeFicheControlePreseries(FicheControlePreserie $ficheControlePreseries): self
  313.     {
  314.         if ($this->ficheControlePreseries->removeElement($ficheControlePreseries)) {
  315.             // set the owning side to null (unless already changed)
  316.             if ($ficheControlePreseries->getAtelier() === $this) {
  317.                 $ficheControlePreseries->setAtelier(null);
  318.             }
  319.         }
  321.         return $this;
  322.     }
  324.     /**
  325.      * @return Collection|ColisageResponsable[]
  326.      */
  327.     public function getColisageResponsables(): Collection
  328.     {
  329.         return $this->colisageResponsables;
  330.     }
  332.     public function addColisageReponsable(ColisageResponsable $colisageReponsable): self
  333.     {
  334.         if (!$this->colisageResponsables->contains($colisageReponsable)) {
  335.             $this->colisageResponsables[] = $colisageReponsable;
  336.             $colisageReponsable->setAtelier($this);
  337.         }
  339.         return $this;
  340.     }
  342.     public function removeColisageReponsable(ColisageResponsable $colisageResponsable): self
  343.     {
  344.         if ($this->colisageResponsables->removeElement($colisageResponsable)) {
  345.             // set the owning side to null (unless already changed)
  346.             if ($colisageResponsable->getAtelier() === $this) {
  347.                 $colisageResponsable->setAtelier(null);
  348.             }
  349.         }
  351.         return $this;
  352.     }
  354.     public function getCodeMagasin(): ?string
  355.     {
  356.         return $this->code_magasin;
  357.     }
  359.     public function setCodeMagasin(?string $code_magasin): self
  360.     {
  361.         $this->code_magasin = $code_magasin;
  363.         return $this;
  364.     }
  366.     /**
  367.      * @return Collection|FicheQualite[]
  368.      */
  369.     public function getFicheQualites(): Collection
  370.     {
  371.         return $this->ficheQualites;
  372.     }
  374.     public function addFicheQualite(FicheQualite $ficheQualite): self
  375.     {
  376.         if (!$this->ficheQualites->contains($ficheQualite)) {
  377.             $this->ficheQualites[] = $ficheQualite;
  378.             $ficheQualite->setAtelier($this);
  379.         }
  381.         return $this;
  382.     }
  384.     public function removeFicheQualite(FicheQualite $ficheQualite): self
  385.     {
  386.         if ($this->ficheQualites->removeElement($ficheQualite)) {
  387.             // set the owning side to null (unless already changed)
  388.             if ($ficheQualite->getAtelier() === $this) {
  389.                 $ficheQualite->setAtelier(null);
  390.             }
  391.         }
  393.         return $this;
  394.     }
  396.     /**
  397.      * @return Collection|FicheQualiteAtelierAuditeur[]
  398.      */
  399.     public function getFicheQualiteAtelierAuditeurs(): Collection
  400.     {
  401.         return $this->ficheQualiteAtelierAuditeurs;
  402.     }
  404.     public function addFicheQualiteAtelierAuditeur(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeur): self
  405.     {
  406.         if (!$this->ficheQualiteAtelierAuditeurs->contains($ficheQualiteAtelierAuditeur)) {
  407.             $this->ficheQualiteAtelierAuditeurs[] = $ficheQualiteAtelierAuditeur;
  408.             $ficheQualiteAtelierAuditeur->setAtelier($this);
  409.         }
  411.         return $this;
  412.     }
  414.     public function removeFicheQualiteAtelierAuditeur(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeur): self
  415.     {
  416.         if ($this->ficheQualiteAtelierAuditeurs->removeElement($ficheQualiteAtelierAuditeur)) {
  417.             // set the owning side to null (unless already changed)
  418.             if ($ficheQualiteAtelierAuditeur->getAtelier() === $this) {
  419.                 $ficheQualiteAtelierAuditeur->setAtelier(null);
  420.             }
  421.         }
  423.         return $this;
  424.     }
  426.     /**
  427.      * @return Collection|FormulaireTeteCollection[]
  428.      */
  429.     public function getFormulaireTeteCollections(): Collection
  430.     {
  431.         return $this->formulaireTeteCollections;
  432.     }
  434.     public function addFormulaireTeteCollection(FormulaireTeteCollection $formulaireTeteCollection): self
  435.     {
  436.         if (!$this->formulaireTeteCollections->contains($formulaireTeteCollection)) {
  437.             $this->formulaireTeteCollections[] = $formulaireTeteCollection;
  438.             $formulaireTeteCollection->setAtelier($this);
  439.         }
  441.         return $this;
  442.     }
  444.     public function removeFormulaireTeteCollection(FormulaireTeteCollection $formulaireTeteCollection): self
  445.     {
  446.         if ($this->formulaireTeteCollections->removeElement($formulaireTeteCollection)) {
  447.             // set the owning side to null (unless already changed)
  448.             if ($formulaireTeteCollection->getAtelier() === $this) {
  449.                 $formulaireTeteCollection->setAtelier(null);
  450.             }
  451.         }
  453.         return $this;
  454.     }
  456.     /**
  457.      * @return Collection|FormulaireCollection[]
  458.      */
  459.     public function getFormulaireCollections(): Collection
  460.     {
  461.         return $this->formulaireCollections;
  462.     }
  464.     public function addFormulaireCollection(FormulaireCollection $formulaireCollection): self
  465.     {
  466.         if (!$this->formulaireCollections->contains($formulaireCollection)) {
  467.             $this->formulaireCollections[] = $formulaireCollection;
  468.             $formulaireCollection->setAtelier($this);
  469.         }
  471.         return $this;
  472.     }
  474.     public function removeFormulaireCollection(FormulaireCollection $formulaireCollection): self
  475.     {
  476.         if ($this->formulaireCollections->removeElement($formulaireCollection)) {
  477.             // set the owning side to null (unless already changed)
  478.             if ($formulaireCollection->getAtelier() === $this) {
  479.                 $formulaireCollection->setAtelier(null);
  480.             }
  481.         }
  483.         return $this;
  484.     }
  486.     /**
  487.      * @return Collection|FicheQualiteSynthese[]
  488.      */
  489.     public function getFicheQualiteSyntheses(): Collection
  490.     {
  491.         return $this->ficheQualiteSyntheses;
  492.     }
  494.     public function addFicheQualiteSynthesis(FicheQualiteSynthese $ficheQualiteSynthesis): self
  495.     {
  496.         if (!$this->ficheQualiteSyntheses->contains($ficheQualiteSynthesis)) {
  497.             $this->ficheQualiteSyntheses[] = $ficheQualiteSynthesis;
  498.             $ficheQualiteSynthesis->setAtelier($this);
  499.         }
  501.         return $this;
  502.     }
  504.     public function removeFicheQualiteSynthesis(FicheQualiteSynthese $ficheQualiteSynthesis): self
  505.     {
  506.         if ($this->ficheQualiteSyntheses->removeElement($ficheQualiteSynthesis)) {
  507.             // set the owning side to null (unless already changed)
  508.             if ($ficheQualiteSynthesis->getAtelier() === $this) {
  509.                 $ficheQualiteSynthesis->setAtelier(null);
  510.             }
  511.         }
  513.         return $this;
  514.     }
  516.     /**
  517.      * @return Collection|FicheQualiteAtelier[]
  518.      */
  519.     public function getFicheQualiteAteliers(): Collection
  520.     {
  521.         return $this->ficheQualiteAteliers;
  522.     }
  524.     public function addFicheQualiteAtelier(FicheQualiteAtelier $ficheQualiteAtelier): self
  525.     {
  526.         if (!$this->ficheQualiteAteliers->contains($ficheQualiteAtelier)) {
  527.             $this->ficheQualiteAteliers[] = $ficheQualiteAtelier;
  528.             $ficheQualiteAtelier->setAtelier($this);
  529.         }
  531.         return $this;
  532.     }
  534.     public function removeFicheQualiteAtelier(FicheQualiteAtelier $ficheQualiteAtelier): self
  535.     {
  536.         if ($this->ficheQualiteAteliers->removeElement($ficheQualiteAtelier)) {
  537.             // set the owning side to null (unless already changed)
  538.             if ($ficheQualiteAtelier->getAtelier() === $this) {
  539.                 $ficheQualiteAtelier->setAtelier(null);
  540.             }
  541.         }
  543.         return $this;
  544.     }
  546.     /**
  547.      * @return Collection|FicheQualiteCent[]
  548.      */
  549.     public function getFicheQualiteCents(): Collection
  550.     {
  551.         return $this->ficheQualiteCents;
  552.     }
  554.     public function addFicheQualiteCent(FicheQualiteCent $ficheQualiteCent): self
  555.     {
  556.         if (!$this->ficheQualiteCents->contains($ficheQualiteCent)) {
  557.             $this->ficheQualiteCents[] = $ficheQualiteCent;
  558.             $ficheQualiteCent->setAtelier($this);
  559.         }
  561.         return $this;
  562.     }
  564.     public function removeFicheQualiteCent(FicheQualiteCent $ficheQualiteCent): self
  565.     {
  566.         if ($this->ficheQualiteCents->removeElement($ficheQualiteCent)) {
  567.             // set the owning side to null (unless already changed)
  568.             if ($ficheQualiteCent->getAtelier() === $this) {
  569.                 $ficheQualiteCent->setAtelier(null);
  570.             }
  571.         }
  573.         return $this;
  574.     }
  576.     /**
  577.      * @return Collection<int, FicheReparation>
  578.      */
  579.     public function getFicheReparations(): Collection
  580.     {
  581.         return $this->ficheReparations;
  582.     }
  584.     public function addFicheReparation(FicheReparation $ficheReparation): self
  585.     {
  586.         if (!$this->ficheReparations->contains($ficheReparation)) {
  587.             $this->ficheReparations[] = $ficheReparation;
  588.             $ficheReparation->setAtelier($this);
  589.         }
  591.         return $this;
  592.     }
  594.     public function removeFicheReparation(FicheReparation $ficheReparation): self
  595.     {
  596.         if ($this->ficheReparations->removeElement($ficheReparation)) {
  597.             // set the owning side to null (unless already changed)
  598.             if ($ficheReparation->getAtelier() === $this) {
  599.                 $ficheReparation->setAtelier(null);
  600.             }
  601.         }
  603.         return $this;
  604.     }
  606.     /**
  607.      * @return Collection<int, FicheControleEnCours>
  608.      */
  609.     public function getFicheControleEnCours(): Collection
  610.     {
  611.         return $this->ficheControleEnCours;
  612.     }
  614.     public function addFicheControleEnCour(FicheControleEnCours $ficheControleEnCour): self
  615.     {
  616.         if (!$this->ficheControleEnCours->contains($ficheControleEnCour)) {
  617.             $this->ficheControleEnCours[] = $ficheControleEnCour;
  618.             $ficheControleEnCour->setAtelier($this);
  619.         }
  621.         return $this;
  622.     }
  624.     public function removeFicheControleEnCour(FicheControleEnCours $ficheControleEnCour): self
  625.     {
  626.         if ($this->ficheControleEnCours->removeElement($ficheControleEnCour)) {
  627.             // set the owning side to null (unless already changed)
  628.             if ($ficheControleEnCour->getAtelier() === $this) {
  629.                 $ficheControleEnCour->setAtelier(null);
  630.             }
  631.         }
  633.         return $this;
  634.     }
  636.     /**
  637.      * @return Collection<int, AtelierChaine>
  638.      */
  639.     public function getAtelierChaines(): Collection
  640.     {
  641.         return $this->atelierChaines;
  642.     }
  644.     public function addAtelierChaine(AtelierChaine $atelierChaine): self
  645.     {
  646.         if (!$this->atelierChaines->contains($atelierChaine)) {
  647.             $this->atelierChaines[] = $atelierChaine;
  648.             $atelierChaine->setAtelier($this);
  649.         }
  651.         return $this;
  652.     }
  654.     public function removeAtelierChaine(AtelierChaine $atelierChaine): self
  655.     {
  656.         if ($this->atelierChaines->removeElement($atelierChaine)) {
  657.             // set the owning side to null (unless already changed)
  658.             if ($atelierChaine->getAtelier() === $this) {
  659.                 $atelierChaine->setAtelier(null);
  660.             }
  661.         }
  663.         return $this;
  664.     }
  666.     public function getAdresse(): ?string
  667.     {
  668.         return $this->adresse;
  669.     }
  671.     public function setAdresse(?string $adresse): self
  672.     {
  673.         $this->adresse = $adresse;
  675.         return $this;
  676.     }
  678.     public function getCodePostal(): ?string
  679.     {
  680.         return $this->code_postal;
  681.     }
  683.     public function setCodePostal(?string $code_postal): self
  684.     {
  685.         $this->code_postal = $code_postal;
  687.         return $this;
  688.     }
  690.     public function getPays(): ?string
  691.     {
  692.         return $this->pays;
  693.     }
  695.     public function setPays(?string $pays): self
  696.     {
  697.         $this->pays = $pays;
  699.         return $this;
  700.     }
  702.     public function getActif(): ?bool
  703.     {
  704.         return $this->actif;
  705.     }
  707.     public function setActif(?bool $actif): self
  708.     {
  709.         $this->actif = $actif;
  711.         return $this;
  712.     }
  714.     /**
  715.      * @return Collection<int, Lancement>
  716.      */
  717.     public function getLancements(): Collection
  718.     {
  719.         return $this->lancements;
  720.     }
  722.     public function addLancement(Lancement $lancement): self
  723.     {
  724.         if (!$this->lancements->contains($lancement)) {
  725.             $this->lancements[] = $lancement;
  726.             $lancement->setAtelier($this);
  727.         }
  729.         return $this;
  730.     }
  732.     public function removeLancement(Lancement $lancement): self
  733.     {
  734.         if ($this->lancements->removeElement($lancement)) {
  735.             // set the owning side to null (unless already changed)
  736.             if ($lancement->getAtelier() === $this) {
  737.                 $lancement->setAtelier(null);
  738.             }
  739.         }
  741.         return $this;
  742.     }
  744.     /**
  745.      * @return Collection<int, Derogation>
  746.      */
  747.     public function getDerogations(): Collection
  748.     {
  749.         return $this->derogations;
  750.     }
  752.     public function addDerogation(Derogation $derogation): self
  753.     {
  754.         if (!$this->derogations->contains($derogation)) {
  755.             $this->derogations[] = $derogation;
  756.             $derogation->setAtelier($this);
  757.         }
  759.         return $this;
  760.     }
  762.     public function removeDerogation(Derogation $derogation): self
  763.     {
  764.         if ($this->derogations->removeElement($derogation)) {
  765.             // set the owning side to null (unless already changed)
  766.             if ($derogation->getAtelier() === $this) {
  767.                 $derogation->setAtelier(null);
  768.             }
  769.         }
  771.         return $this;
  772.     }
  774.     /**
  775.      * @return Collection<int, DerogationSynthese>
  776.      */
  777.     public function getDerogationSyntheses(): Collection
  778.     {
  779.         return $this->derogationSyntheses;
  780.     }
  782.     public function addDerogationSynthesis(DerogationSynthese $derogationSynthesis): self
  783.     {
  784.         if (!$this->derogationSyntheses->contains($derogationSynthesis)) {
  785.             $this->derogationSyntheses[] = $derogationSynthesis;
  786.             $derogationSynthesis->setAtelier($this);
  787.         }
  789.         return $this;
  790.     }
  792.     public function removeDerogationSynthesis(DerogationSynthese $derogationSynthesis): self
  793.     {
  794.         if ($this->derogationSyntheses->removeElement($derogationSynthesis)) {
  795.             // set the owning side to null (unless already changed)
  796.             if ($derogationSynthesis->getAtelier() === $this) {
  797.                 $derogationSynthesis->setAtelier(null);
  798.             }
  799.         }
  801.         return $this;
  802.     }
  804.     /**
  805.      * @return Collection<int, FicheAvoir>
  806.      */
  807.     public function getFicheAvoirs(): Collection
  808.     {
  809.         return $this->ficheAvoirs;
  810.     }
  812.     public function addFicheAvoir(FicheAvoir $ficheAvoir): self
  813.     {
  814.         if (!$this->ficheAvoirs->contains($ficheAvoir)) {
  815.             $this->ficheAvoirs[] = $ficheAvoir;
  816.             $ficheAvoir->setAtelier($this);
  817.         }
  819.         return $this;
  820.     }
  822.     public function removeFicheAvoir(FicheAvoir $ficheAvoir): self
  823.     {
  824.         if ($this->ficheAvoirs->removeElement($ficheAvoir)) {
  825.             // set the owning side to null (unless already changed)
  826.             if ($ficheAvoir->getAtelier() === $this) {
  827.                 $ficheAvoir->setAtelier(null);
  828.             }
  829.         }
  831.         return $this;
  832.     }
  834.     public function getType(): ?string
  835.     {
  836.         return $this->type;
  837.     }
  839.     public function setType(?string $type): static
  840.     {
  841.         $this->type = $type;
  843.         return $this;
  844.     }
  846.     /**
  847.      * @return Collection<int, MailIndicateurQualite>
  848.      */
  849.     public function getMailIndicateurQualites(): Collection
  850.     {
  851.         return $this->mailIndicateurQualites;
  852.     }
  854.     public function addMailIndicateurQualite(MailIndicateurQualite $mailIndicateurQualite): static
  855.     {
  856.         if (!$this->mailIndicateurQualites->contains($mailIndicateurQualite)) {
  857.             $this->mailIndicateurQualites->add($mailIndicateurQualite);
  858.             $mailIndicateurQualite->setAtelier($this);
  859.         }
  861.         return $this;
  862.     }
  864.     public function removeMailIndicateurQualite(MailIndicateurQualite $mailIndicateurQualite): static
  865.     {
  866.         if ($this->mailIndicateurQualites->removeElement($mailIndicateurQualite)) {
  867.             // set the owning side to null (unless already changed)
  868.             if ($mailIndicateurQualite->getAtelier() === $this) {
  869.                 $mailIndicateurQualite->setAtelier(null);
  870.             }
  871.         }
  873.         return $this;
  874.     }
  876. }