src/Entity/User.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Component\Security\Core\User\UserInterface;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. #[ORM\Table(name: '`user`')]
  13. #[ORM\Entity(repositoryClass: UserRepository::class)]
  14. class User implements UserInterface, PasswordAuthenticatedUserInterface, \Stringable
  15. {
  16.     #[ORM\Id]
  17.     #[ORM\GeneratedValue]
  18.     #[ORM\Column(type: 'integer')]
  19.     private $id;
  21.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  22.     private $email;
  24.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  25.     private $password;
  27.     protected $plainPassword;
  29.     private array $roles = [];
  31.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  32.     private $prenom;
  34.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  35.     private $nom;
  37.     #[ORM\ManyToOne(targetEntity: Droit::class, inversedBy: 'users')]
  38.     private $droit;
  40.     private $role;
  42.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  43.     private $token_password;
  45.     #[ORM\Column(type: 'boolean', nullable: true)]
  46.     private $active;
  48.     #[ORM\ManyToOne(targetEntity: Fournisseur::class, inversedBy: 'users')]
  49.     private $fournisseur;
  51.     #[ORM\ManyToOne(targetEntity: Atelier::class, inversedBy: 'users')]
  52.     private $atelier;
  54.     #[ORM\ManyToMany(targetEntity: \App\Entity\GroupesUtilisateur::class, inversedBy: 'utilisateurs')]
  55.     private $groupes;
  57.     #[ORM\OneToMany(targetEntity: FicheControlePreserie::class, mappedBy: 'user_ouvre')]
  58.     private $ficheControlePreseries;
  60.     #[ORM\OneToMany(targetEntity: Colisage::class, mappedBy: 'user_affecte')]
  61.     private $colisages;
  63.     #[ORM\OneToMany(targetEntity: ColisageResponsable::class, mappedBy: 'user_affecte')]
  64.     private $colisageResponsables;
  66.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  67.     private $rendement;
  69.     #[ORM\Column(type: 'integer', nullable: true)]
  70.     private $lundi;
  72.     #[ORM\Column(type: 'integer', nullable: true)]
  73.     private $mardi;
  75.     #[ORM\Column(type: 'integer', nullable: true)]
  76.     private $mercredi;
  78.     #[ORM\Column(type: 'integer', nullable: true)]
  79.     private $jeudi;
  81.     #[ORM\Column(type: 'integer', nullable: true)]
  82.     private $vendredi;
  84.     #[ORM\OneToMany(targetEntity: FicheQualite::class, mappedBy: 'user_ferme')]
  85.     private $ficheQualitesFerme;
  87.     #[ORM\OneToMany(targetEntity: FicheQualite::class, mappedBy: 'user_ouvre')]
  88.     private $ficheQualitesOuvre;
  90.     #[ORM\OneToMany(targetEntity: FicheQualiteAtelierAuditeur::class, mappedBy: 'user_ouvre')]
  91.     private $ficheQualiteAtelierAuditeurs;
  93.     #[ORM\OneToMany(targetEntity: FicheQualiteAtelierAuditeur::class, mappedBy: 'user_ferme')]
  94.     private $ficheQualiteAtelierAuditeursFerme;
  96.     #[ORM\OneToMany(targetEntity: FicheControlePreserie::class, mappedBy: 'user_atelier')]
  97.     private $ficheControlePreseriesAtelier;
  99.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  100.     private ?string $langue = 'fr';
  102.     #[ORM\OneToMany(targetEntity: FicheQualiteAtelier::class, mappedBy: 'user_ouvre')]
  103.     private $ficheQualiteAteliers;
  105.     #[ORM\OneToMany(targetEntity: FicheQualiteCent::class, mappedBy: 'user_ouvre')]
  106.     private $ficheQualiteCents;
  108.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  109.     private $matricule;
  111.     #[ORM\OneToMany(targetEntity: FicheQualiteAtelier::class, mappedBy: 'controleur')]
  112.     private $ficheQualiteAtelierControleur;
  114.     #[ORM\OneToMany(targetEntity: FicheQualiteAtelierAuditeur::class, mappedBy: 'controleur')]
  115.     private $ficheQualiteAtelierAuditeursControleur;
  117.     #[ORM\OneToMany(targetEntity: FicheQualiteAtelierAuditeur::class, mappedBy: 'auditeur')]
  118.     private $ficheQualiteAtelierAuditeurAuditeur;
  120.     #[ORM\OneToMany(targetEntity: FicheControleEnCoursDefaut::class, mappedBy: 'controleur')]
  121.     private $ficheControleEnCoursDefauts;
  123.     #[ORM\Column(type: 'boolean', nullable: true)]
  124.     private $cotraitance;
  126.     #[ORM\OneToMany(targetEntity: FicheAvoir::class, mappedBy: 'user_avoir_ferme')]
  127.     private $ficheAvoirsFerme;
  129.     #[ORM\OneToMany(targetEntity: FicheAvoir::class, mappedBy: 'user_qualite')]
  130.     private $ficheAvoirsQualite;
  132.     public function __construct()
  133.     {
  134.         $this->groupes = new ArrayCollection();
  135.         $this->ficheControlePreseries = new ArrayCollection();
  136.         $this->colisages = new ArrayCollection();
  137.         $this->colisageResponsables = new ArrayCollection();
  138.         $this->ficheQualitesFerme = new ArrayCollection();
  139.         $this->ficheQualitesOuvre = new ArrayCollection();
  140.         $this->ficheQualiteAtelierAuditeurs = new ArrayCollection();
  141.         $this->ficheQualiteAtelierAuditeursFerme = new ArrayCollection();
  142.         $this->ficheControlePreseriesAtelier = new ArrayCollection();
  143.         $this->ficheQualiteAteliers = new ArrayCollection();
  144.         $this->ficheQualiteCents = new ArrayCollection();
  145.         $this->ficheQualiteAtelierControleur = new ArrayCollection();
  146.         $this->ficheQualiteAtelierAuditeursControleur = new ArrayCollection();
  147.         $this->ficheQualiteAtelierAuditeurAuditeur = new ArrayCollection();
  148.         $this->ficheControleEnCoursDefauts = new ArrayCollection();
  149.         $this->ficheAvoirsFerme = new ArrayCollection();
  150.         $this->ficheAvoirsQualite = new ArrayCollection();
  151.     }
  152.     /**
  153.      * @return Collection|GroupesUtilisateur[]
  154.      */
  155.     public function getGroupes(): Collection
  156.     {
  157.         return $this->groupes;
  158.     }
  160.     public function addGroupe(GroupesUtilisateur $groupe): self
  161.     {
  162.         if (!$this->groupes->contains($groupe)) {
  163.             $this->groupes[] = $groupe;
  164.         }
  166.         return $this;
  167.     }
  169.     public function removeGroupe(GroupesUtilisateur $groupe): self
  170.     {
  171.         if ($this->groupes->contains($groupe)) {
  172.             $this->groupes->removeElement($groupe);
  173.         }
  175.         return $this;
  176.     }
  177.     public function getTokenPassword(): ?string
  178.     {
  179.         return $this->token_password;
  180.     }
  182.     public function setTokenPassword(?string $token_password): self
  183.     {
  184.         $this->token_password = $token_password;
  186.         return $this;
  187.     }
  189.     public function getPlainPassword()
  190.     {
  191.         return $this->plainPassword;
  192.     }
  194.     public function setPlainPassword($password)
  195.     {
  196.         $this->plainPassword = $password;
  197.     }
  199.     public function getRole()
  200.     {
  201.         return $this->getDroit()->getRole();
  202.     }
  203.     public function getId(): ?int
  204.     {
  205.         return $this->id;
  206.     }
  208.     public function getEmail(): ?string
  209.     {
  210.         return $this->email;
  211.     }
  213.     public function setEmail(?string $email): self
  214.     {
  215.         $this->email = $email;
  217.         return $this;
  218.     }
  220.     public function getPassword(): ?string
  221.     {
  222.         return $this->password;
  223.     }
  225.     public function setPassword(?string $password): self
  226.     {
  227.         $this->password = $password;
  229.         return $this;
  230.     }
  232.     public function getRoles(): array
  233.     {
  234.         $roles = [];
  235.         $roles[] = $this->getDroit()->getRole();
  236.         return array_unique($roles);
  237.     }
  239.     public function setRoles(?string $roles): self
  240.     {
  241.         $this->roles = $roles;
  243.         return $this;
  244.     }
  246.     public function getSalt(): ?string
  247.     {
  248.         return null;
  249.     }
  251.     public function getUsername(): string
  252.     {
  253.         return $this->email;
  254.     }
  255.     public function getUserIdentifier(): string
  256.     {
  257.         return $this->email;
  258.     }
  260.     public function eraseCredentials()
  261.     {
  262.         // Suppression des données sensibles
  263.         $this->plainPassword = null;
  264.     }
  265.     public function isEqualTo(UserInterface $user)
  266.     {
  267.         //if (!$user instanceof $this) {
  268.         //    return false;
  269.         //}
  271.         if ($this->password !== $user->getPassword()) {
  272.             return false;
  273.         }
  275.         return true;
  276.     }
  278.     public function getPrenom(): ?string
  279.     {
  280.         return $this->prenom;
  281.     }
  283.     public function setPrenom(?string $prenom): self
  284.     {
  285.         $this->prenom = $prenom;
  287.         return $this;
  288.     }
  290.     public function getNom(): ?string
  291.     {
  292.         return $this->nom;
  293.     }
  295.     public function setNom(?string $nom): self
  296.     {
  297.         $this->nom = $nom;
  299.         return $this;
  300.     }
  302.     public function getDroit(): ?Droit
  303.     {
  304.         return $this->droit;
  305.     }
  307.     public function setDroit(?Droit $droit): self
  308.     {
  309.         $this->droit = $droit;
  311.         return $this;
  312.     }
  314.     public function getActive(): ?bool
  315.     {
  316.         return $this->active;
  317.     }
  319.     public function setActive(?bool $active): self
  320.     {
  321.         $this->active = $active;
  323.         return $this;
  324.     }
  326.     public function getFournisseur(): ?Fournisseur
  327.     {
  328.         return $this->fournisseur;
  329.     }
  331.     public function setFournisseur(?Fournisseur $fournisseur): self
  332.     {
  333.         $this->fournisseur = $fournisseur;
  335.         return $this;
  336.     }
  338.     public function getAtelier(): ?Atelier
  339.     {
  340.         return $this->atelier;
  341.     }
  343.     public function setAtelier(?Atelier $atelier): self
  344.     {
  345.         $this->atelier = $atelier;
  347.         return $this;
  348.     }
  350.     /**
  351.      * @return Collection|FicheControlePreserie[]
  352.      */
  353.     public function getFicheControlePreseries(): Collection
  354.     {
  355.         return $this->ficheControlePreseries;
  356.     }
  358.     public function addFicheControlePreseries(FicheControlePreserie $ficheControlePreseries): self
  359.     {
  360.         if (!$this->ficheControlePreseries->contains($ficheControlePreseries)) {
  361.             $this->ficheControlePreseries[] = $ficheControlePreseries;
  362.             $ficheControlePreseries->setUserOuvre($this);
  363.         }
  365.         return $this;
  366.     }
  368.     public function removeFicheControlePreseries(FicheControlePreserie $ficheControlePreseries): self
  369.     {
  370.         if ($this->ficheControlePreseries->removeElement($ficheControlePreseries)) {
  371.             // set the owning side to null (unless already changed)
  372.             if ($ficheControlePreseries->getUserOuvre() === $this) {
  373.                 $ficheControlePreseries->setUserOuvre(null);
  374.             }
  375.         }
  377.         return $this;
  378.     }
  380.     /**
  381.      * @return Collection|Colisage[]
  382.      */
  383.     public function getColisages(): Collection
  384.     {
  385.         return $this->colisages;
  386.     }
  388.     public function addColisage(Colisage $colisage): self
  389.     {
  390.         if (!$this->colisages->contains($colisage)) {
  391.             $this->colisages[] = $colisage;
  392.             $colisage->setUserAffecte($this);
  393.         }
  395.         return $this;
  396.     }
  398.     public function removeColisage(Colisage $colisage): self
  399.     {
  400.         if ($this->colisages->removeElement($colisage)) {
  401.             // set the owning side to null (unless already changed)
  402.             if ($colisage->getUserAffecte() === $this) {
  403.                 $colisage->setUserAffecte(null);
  404.             }
  405.         }
  407.         return $this;
  408.     }
  410.     /**
  411.      * @return Collection|ColisageResponsable[]
  412.      */
  413.     public function getColisageResponsables(): Collection
  414.     {
  415.         return $this->colisageResponsables;
  416.     }
  418.     public function addColisageResponsable(ColisageResponsable $colisageResponsable): self
  419.     {
  420.         if (!$this->colisageResponsables->contains($colisageResponsable)) {
  421.             $this->colisageResponsables[] = $colisageResponsable;
  422.             $colisageResponsable->setUserAffecte($this);
  423.         }
  425.         return $this;
  426.     }
  428.     public function removeColisageResponsable(ColisageResponsable $colisageReponsable): self
  429.     {
  430.         if ($this->colisageReponsables->removeElement($colisageReponsable)) {
  431.             // set the owning side to null (unless already changed)
  432.             if ($colisageReponsable->getUserAffecte() === $this) {
  433.                 $colisageReponsable->setUserAffecte(null);
  434.             }
  435.         }
  437.         return $this;
  438.     }
  440.     public function getRendement(): ?string
  441.     {
  442.         return $this->rendement;
  443.     }
  445.     public function setRendement(?string $rendement): self
  446.     {
  447.         $this->rendement = $rendement;
  449.         return $this;
  450.     }
  452.     public function __toString(): string
  453.     {
  454.         $return = "";
  455.         if($this->matricule != null){
  456.             $return .= $this->matricule." - ";
  457.         }
  458.         $return .= $this->prenom.' '.$this->nom;
  459.         
  460.         return $return;
  461.     }
  463.     public function getLundi(): ?int
  464.     {
  465.         return $this->lundi;
  466.     }
  468.     public function setLundi(?int $lundi): self
  469.     {
  470.         $this->lundi = $lundi;
  472.         return $this;
  473.     }
  475.     public function getMardi(): ?int
  476.     {
  477.         return $this->mardi;
  478.     }
  480.     public function setMardi(?int $mardi): self
  481.     {
  482.         $this->mardi = $mardi;
  484.         return $this;
  485.     }
  487.     public function getMercredi(): ?int
  488.     {
  489.         return $this->mercredi;
  490.     }
  492.     public function setMercredi(?int $mercredi): self
  493.     {
  494.         $this->mercredi = $mercredi;
  496.         return $this;
  497.     }
  499.     public function getJeudi(): ?int
  500.     {
  501.         return $this->jeudi;
  502.     }
  504.     public function setJeudi(?int $jeudi): self
  505.     {
  506.         $this->jeudi = $jeudi;
  508.         return $this;
  509.     }
  511.     public function getVendredi(): ?int
  512.     {
  513.         return $this->vendredi;
  514.     }
  516.     public function setVendredi(?int $vendredi): self
  517.     {
  518.         $this->vendredi = $vendredi;
  520.         return $this;
  521.     }
  523.     /**
  524.      * @return Collection|FicheQualite[]
  525.      */
  526.     public function getFicheQualitesFerme(): Collection
  527.     {
  528.         return $this->ficheQualitesFerme;
  529.     }
  531.     public function addFicheQualiteFerme(FicheQualite $ficheQualite): self
  532.     {
  533.         if (!$this->ficheQualitesFerme->contains($ficheQualite)) {
  534.             $this->ficheQualitesFerme[] = $ficheQualite;
  535.             $ficheQualite->setUserFerme($this);
  536.         }
  538.         return $this;
  539.     }
  541.     public function removeFicheQualiteFerme(FicheQualite $ficheQualite): self
  542.     {
  543.         if ($this->ficheQualitesFerme->removeElement($ficheQualite)) {
  544.             // set the owning side to null (unless already changed)
  545.             if ($ficheQualite->getUserFerme() === $this) {
  546.                 $ficheQualite->setUserFerme(null);
  547.             }
  548.         }
  550.         return $this;
  551.     }
  553.     /**
  554.      * @return Collection|FicheQualite[]
  555.      */
  556.     public function getFicheQualitesOuvre(): Collection
  557.     {
  558.         return $this->ficheQualitesOuvre;
  559.     }
  561.     public function addFicheQualiteOuvre(FicheQualite $ficheQualite): self
  562.     {
  563.         if (!$this->ficheQualitesOuvre->contains($ficheQualite)) {
  564.             $this->ficheQualitesOuvre[] = $ficheQualite;
  565.             $ficheQualite->setUserOuvre($this);
  566.         }
  568.         return $this;
  569.     }
  571.     public function removeFicheQualiteOuvre(FicheQualite $ficheQualite): self
  572.     {
  573.         if ($this->ficheQualitesOuvre->removeElement($ficheQualite)) {
  574.             // set the owning side to null (unless already changed)
  575.             if ($ficheQualite->getUserOuvre() === $this) {
  576.                 $ficheQualite->setUserOuvre(null);
  577.             }
  578.         }
  580.         return $this;
  581.     }
  583.     /**
  584.      * @return Collection|FicheQualiteAtelierAuditeur[]
  585.      */
  586.     public function getFicheQualiteAtelierAuditeurs(): Collection
  587.     {
  588.         return $this->ficheQualiteAtelierAuditeurs;
  589.     }
  591.     public function addFicheQualiteAtelierAuditeur(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeur): self
  592.     {
  593.         if (!$this->ficheQualiteAtelierAuditeurs->contains($ficheQualiteAtelierAuditeur)) {
  594.             $this->ficheQualiteAtelierAuditeurs[] = $ficheQualiteAtelierAuditeur;
  595.             $ficheQualiteAtelierAuditeur->setUserOuvre($this);
  596.         }
  598.         return $this;
  599.     }
  601.     public function removeFicheQualiteAtelierAuditeur(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeur): self
  602.     {
  603.         if ($this->ficheQualiteAtelierAuditeurs->removeElement($ficheQualiteAtelierAuditeur)) {
  604.             // set the owning side to null (unless already changed)
  605.             if ($ficheQualiteAtelierAuditeur->getUserOuvre() === $this) {
  606.                 $ficheQualiteAtelierAuditeur->setUserOuvre(null);
  607.             }
  608.         }
  610.         return $this;
  611.     }
  613.     /**
  614.      * @return Collection|FicheQualiteAtelierAuditeur[]
  615.      */
  616.     public function getFicheQualiteAtelierAuditeursFerme(): Collection
  617.     {
  618.         return $this->ficheQualiteAtelierAuditeursFerme;
  619.     }
  621.     public function addFicheQualiteAtelierAuditeursFerme(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeursFerme): self
  622.     {
  623.         if (!$this->ficheQualiteAtelierAuditeursFerme->contains($ficheQualiteAtelierAuditeursFerme)) {
  624.             $this->ficheQualiteAtelierAuditeursFerme[] = $ficheQualiteAtelierAuditeursFerme;
  625.             $ficheQualiteAtelierAuditeursFerme->setUserFerme($this);
  626.         }
  628.         return $this;
  629.     }
  631.     public function removeFicheQualiteAtelierAuditeursFerme(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeursFerme): self
  632.     {
  633.         if ($this->ficheQualiteAtelierAuditeursFerme->removeElement($ficheQualiteAtelierAuditeursFerme)) {
  634.             // set the owning side to null (unless already changed)
  635.             if ($ficheQualiteAtelierAuditeursFerme->getUserFerme() === $this) {
  636.                 $ficheQualiteAtelierAuditeursFerme->setUserFerme(null);
  637.             }
  638.         }
  640.         return $this;
  641.     }
  643.     /**
  644.      * @return Collection|FicheControlePreserie[]
  645.      */
  646.     public function getFicheControlePreseriesAtelier(): Collection
  647.     {
  648.         return $this->ficheControlePreseriesAtelier;
  649.     }
  651.     public function addFicheControlePreseriesAtelier(FicheControlePreserie $ficheControlePreseriesAtelier): self
  652.     {
  653.         if (!$this->ficheControlePreseriesAtelier->contains($ficheControlePreseriesAtelier)) {
  654.             $this->ficheControlePreseriesAtelier[] = $ficheControlePreseriesAtelier;
  655.             $ficheControlePreseriesAtelier->setUserAtelier($this);
  656.         }
  658.         return $this;
  659.     }
  661.     public function removeFicheControlePreseriesAtelier(FicheControlePreserie $ficheControlePreseriesAtelier): self
  662.     {
  663.         if ($this->ficheControlePreseriesAtelier->removeElement($ficheControlePreseriesAtelier)) {
  664.             // set the owning side to null (unless already changed)
  665.             if ($ficheControlePreseriesAtelier->getUserAtelier() === $this) {
  666.                 $ficheControlePreseriesAtelier->setUserAtelier(null);
  667.             }
  668.         }
  670.         return $this;
  671.     }
  673.     public function getLangue(): ?string
  674.     {
  675.         return $this->langue;
  676.     }
  678.     public function setLangue(?string $langue): self
  679.     {
  680.         $this->langue = $langue;
  682.         return $this;
  683.     }
  685.     /**
  686.      * @return Collection|FicheQualiteAtelier[]
  687.      */
  688.     public function getFicheQualiteAteliers(): Collection
  689.     {
  690.         return $this->ficheQualiteAteliers;
  691.     }
  693.     public function addFicheQualiteAtelier(FicheQualiteAtelier $ficheQualiteAtelier): self
  694.     {
  695.         if (!$this->ficheQualiteAteliers->contains($ficheQualiteAtelier)) {
  696.             $this->ficheQualiteAteliers[] = $ficheQualiteAtelier;
  697.             $ficheQualiteAtelier->setUserOuvre($this);
  698.         }
  700.         return $this;
  701.     }
  703.     public function removeFicheQualiteAtelier(FicheQualiteAtelier $ficheQualiteAtelier): self
  704.     {
  705.         if ($this->ficheQualiteAteliers->removeElement($ficheQualiteAtelier)) {
  706.             // set the owning side to null (unless already changed)
  707.             if ($ficheQualiteAtelier->getUserOuvre() === $this) {
  708.                 $ficheQualiteAtelier->setUserOuvre(null);
  709.             }
  710.         }
  712.         return $this;
  713.     }
  715.     /**
  716.      * @return Collection|FicheQualiteCent[]
  717.      */
  718.     public function getFicheQualiteCents(): Collection
  719.     {
  720.         return $this->ficheQualiteCents;
  721.     }
  723.     public function addFicheQualiteCent(FicheQualiteCent $ficheQualiteCent): self
  724.     {
  725.         if (!$this->ficheQualiteCents->contains($ficheQualiteCent)) {
  726.             $this->ficheQualiteCents[] = $ficheQualiteCent;
  727.             $ficheQualiteCent->setUserOuvre($this);
  728.         }
  730.         return $this;
  731.     }
  733.     public function removeFicheQualiteCent(FicheQualiteCent $ficheQualiteCent): self
  734.     {
  735.         if ($this->ficheQualiteCents->removeElement($ficheQualiteCent)) {
  736.             // set the owning side to null (unless already changed)
  737.             if ($ficheQualiteCent->getUserOuvre() === $this) {
  738.                 $ficheQualiteCent->setUserOuvre(null);
  739.             }
  740.         }
  742.         return $this;
  743.     }
  745.     public function getMatricule(): ?string
  746.     {
  747.         return $this->matricule;
  748.     }
  750.     public function setMatricule(?string $matricule): self
  751.     {
  752.         $this->matricule = $matricule;
  754.         return $this;
  755.     }
  757.     /**
  758.      * @return Collection|FicheQualiteAtelier[]
  759.      */
  760.     public function getFicheQualiteAtelierControleur(): Collection
  761.     {
  762.         return $this->ficheQualiteAtelierControleur;
  763.     }
  765.     public function addFicheQualiteAtelierControleur(FicheQualiteAtelier $ficheQualiteAtelierControleur): self
  766.     {
  767.         if (!$this->ficheQualiteAtelierControleur->contains($ficheQualiteAtelierControleur)) {
  768.             $this->ficheQualiteAtelierControleur[] = $ficheQualiteAtelierControleur;
  769.             $ficheQualiteAtelierControleur->setControleur($this);
  770.         }
  772.         return $this;
  773.     }
  775.     public function removeFicheQualiteAtelierControleur(FicheQualiteAtelier $ficheQualiteAtelierControleur): self
  776.     {
  777.         if ($this->ficheQualiteAtelierControleur->removeElement($ficheQualiteAtelierControleur)) {
  778.             // set the owning side to null (unless already changed)
  779.             if ($ficheQualiteAtelierControleur->getControleur() === $this) {
  780.                 $ficheQualiteAtelierControleur->setControleur(null);
  781.             }
  782.         }
  784.         return $this;
  785.     }
  787.     /**
  788.      * @return Collection|FicheQualiteAtelierAuditeur[]
  789.      */
  790.     public function getFicheQualiteAtelierAuditeursControleur(): Collection
  791.     {
  792.         return $this->ficheQualiteAtelierAuditeursControleur;
  793.     }
  795.     public function addFicheQualiteAtelierAuditeursControleur(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeursControleur): self
  796.     {
  797.         if (!$this->ficheQualiteAtelierAuditeursControleur->contains($ficheQualiteAtelierAuditeursControleur)) {
  798.             $this->ficheQualiteAtelierAuditeursControleur[] = $ficheQualiteAtelierAuditeursControleur;
  799.             $ficheQualiteAtelierAuditeursControleur->setControleur($this);
  800.         }
  802.         return $this;
  803.     }
  805.     public function removeFicheQualiteAtelierAuditeursControleur(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeursControleur): self
  806.     {
  807.         if ($this->ficheQualiteAtelierAuditeursControleur->removeElement($ficheQualiteAtelierAuditeursControleur)) {
  808.             // set the owning side to null (unless already changed)
  809.             if ($ficheQualiteAtelierAuditeursControleur->getControleur() === $this) {
  810.                 $ficheQualiteAtelierAuditeursControleur->setControleur(null);
  811.             }
  812.         }
  814.         return $this;
  815.     }
  817.     /**
  818.      * @return Collection|FicheQualiteAtelierAuditeur[]
  819.      */
  820.     public function getFicheQualiteAtelierAuditeurAuditeur(): Collection
  821.     {
  822.         return $this->ficheQualiteAtelierAuditeurAuditeur;
  823.     }
  825.     public function addFicheQualiteAtelierAuditeurAuditeur(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeurAuditeur): self
  826.     {
  827.         if (!$this->ficheQualiteAtelierAuditeurAuditeur->contains($ficheQualiteAtelierAuditeurAuditeur)) {
  828.             $this->ficheQualiteAtelierAuditeurAuditeur[] = $ficheQualiteAtelierAuditeurAuditeur;
  829.             $ficheQualiteAtelierAuditeurAuditeur->setAuditeur($this);
  830.         }
  832.         return $this;
  833.     }
  835.     public function removeFicheQualiteAtelierAuditeurAuditeur(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeurAuditeur): self
  836.     {
  837.         if ($this->ficheQualiteAtelierAuditeurAuditeur->removeElement($ficheQualiteAtelierAuditeurAuditeur)) {
  838.             // set the owning side to null (unless already changed)
  839.             if ($ficheQualiteAtelierAuditeurAuditeur->getAuditeur() === $this) {
  840.                 $ficheQualiteAtelierAuditeurAuditeur->setAuditeur(null);
  841.             }
  842.         }
  844.         return $this;
  845.     }
  847.     /**
  848.      * @return Collection<int, FicheControleEnCoursDefaut>
  849.      */
  850.     public function getFicheControleEnCoursDefauts(): Collection
  851.     {
  852.         return $this->ficheControleEnCoursDefauts;
  853.     }
  855.     public function addFicheControleEnCoursDefaut(FicheControleEnCoursDefaut $ficheControleEnCoursDefaut): self
  856.     {
  857.         if (!$this->ficheControleEnCoursDefauts->contains($ficheControleEnCoursDefaut)) {
  858.             $this->ficheControleEnCoursDefauts[] = $ficheControleEnCoursDefaut;
  859.             $ficheControleEnCoursDefaut->setControleur($this);
  860.         }
  862.         return $this;
  863.     }
  865.     public function removeFicheControleEnCoursDefaut(FicheControleEnCoursDefaut $ficheControleEnCoursDefaut): self
  866.     {
  867.         if ($this->ficheControleEnCoursDefauts->removeElement($ficheControleEnCoursDefaut)) {
  868.             // set the owning side to null (unless already changed)
  869.             if ($ficheControleEnCoursDefaut->getControleur() === $this) {
  870.                 $ficheControleEnCoursDefaut->setControleur(null);
  871.             }
  872.         }
  874.         return $this;
  875.     }
  877.     public function getCotraitance(): ?bool
  878.     {
  879.         return $this->cotraitance;
  880.     }
  882.     public function setCotraitance(?bool $cotraitance): self
  883.     {
  884.         $this->cotraitance = $cotraitance;
  886.         return $this;
  887.     }
  889.     /**
  890.      * @return Collection<int, FicheAvoir>
  891.      */
  892.     public function getFicheAvoirsFerme(): Collection
  893.     {
  894.         return $this->ficheAvoirsFerme;
  895.     }
  897.     public function addFicheAvoirsFerme(FicheAvoir $ficheAvoirsFerme): self
  898.     {
  899.         if (!$this->ficheAvoirsFerme->contains($ficheAvoirsFerme)) {
  900.             $this->ficheAvoirsFerme[] = $ficheAvoirsFerme;
  901.             $ficheAvoirsFerme->setUserAvoirFerme($this);
  902.         }
  904.         return $this;
  905.     }
  907.     public function removeFicheAvoirsFerme(FicheAvoir $ficheAvoirsFerme): self
  908.     {
  909.         if ($this->ficheAvoirsFerme->removeElement($ficheAvoirsFerme)) {
  910.             // set the owning side to null (unless already changed)
  911.             if ($ficheAvoirsFerme->getUserAvoirFerme() === $this) {
  912.                 $ficheAvoirsFerme->setUserAvoirFerme(null);
  913.             }
  914.         }
  916.         return $this;
  917.     }
  919.     /**
  920.      * @return Collection<int, FicheAvoir>
  921.      */
  922.     public function getFicheAvoirsQualite(): Collection
  923.     {
  924.         return $this->ficheAvoirsQualite;
  925.     }
  927.     public function addFicheAvoirsQualite(FicheAvoir $ficheAvoirsQualite): self
  928.     {
  929.         if (!$this->ficheAvoirsQualite->contains($ficheAvoirsQualite)) {
  930.             $this->ficheAvoirsQualite[] = $ficheAvoirsQualite;
  931.             $ficheAvoirsQualite->setUserQualite($this);
  932.         }
  934.         return $this;
  935.     }
  937.     public function removeFicheAvoirsQualite(FicheAvoir $ficheAvoirsQualite): self
  938.     {
  939.         if ($this->ficheAvoirsQualite->removeElement($ficheAvoirsQualite)) {
  940.             // set the owning side to null (unless already changed)
  941.             if ($ficheAvoirsQualite->getUserQualite() === $this) {
  942.                 $ficheAvoirsQualite->setUserQualite(null);
  943.             }
  944.         }
  946.         return $this;
  947.     }
  948. }