src/Entity/User.php line 20

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use DateTimeImmutable;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\Form\Exception\InvalidArgumentException;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  14. use Symfony\Component\Serializer\Annotation\Groups;
  16. #[ORM\Entity(repositoryClass: UserRepository::class)]
  17. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  18. #[ORM\HasLifecycleCallbacks]
  19. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  20. class User implements UserInterface, PasswordAuthenticatedUserInterface
  21. {
  22.     #[ORM\Id]
  23.     #[ORM\GeneratedValue]
  24.     #[ORM\Column(type: 'integer')]
  25.     #[Groups(['user:read', 'membre:read', 'meetParticipant:read','task:read'])]
  26.     private ?int $id;
  28.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  29.     #[Groups(['user:read',  'membre:read', 'meetParticipant:read', 'task:read','documentProjet:read'])]
  30.     private ?string $email;
  32.     #[ORM\Column(type: 'json')]
  33.     #[Groups(['user:read', 'task:read'])]
  34.     private array $roles = [];
  36.     #[ORM\Column(type: 'string')]
  37.     private string $password;
  39.     #[ORM\Column(type: 'boolean')]
  40.     private bool $isVerified = false;
  42.     #[ORM\Column(type: 'boolean')]
  43.     private bool $isEnabled = true;
  45.     #[ORM\Column(type: 'string', length: 30)]
  46.     #[Groups(['user:read'])]
  47.     private ?string $gender;
  49.     #[ORM\Column(type: 'string', length: 255)]
  50.     #[Groups(['user:read', 'membre:read', 'meetParticipant:read', 'task:read'])]
  51.     private ?string $firstname;
  53.     #[ORM\Column(type: 'string', length: 255)]
  54.     #[Groups(['user:read', 'membre:read','meetParticipant:read', 'task:read'])]
  55.     private ?string $lastname;
  57.     #[ORM\Column(type: 'string', length: 30)]
  58.     #[Groups(['user:read', 'membre:read', 'meetParticipant:read','task:read'])]
  59.     private ?string $phone;
  61.     #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  62.     private ?DateTimeImmutable $lastLoginAt;
  64.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  65.     private ?string $createdBy;
  67.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  68.     private ?string $updatedBy;
  70.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  71.     private ?string $address;
  73.     #[ORM\Column(type: 'string', length: 45, nullable: true)]
  74.     private ?string $district;
  75. /*
  76.     #[ORM\ManyToOne(targetEntity: Municipality::class, inversedBy: 'users')]
  77.     #[ORM\JoinColumn(nullable: true)]
  78.     private mixed $municipality;
  79. */
  80.     #[ORM\ManyToOne]
  81.     #[ORM\JoinColumn(nullable: true)]
  82.     private ?Municipality $municipality = null;
  84.     #[ORM\ManyToOne]
  85.     #[Groups(['user:read', 'membre:read', 'meetParticipant:read'])]
  86.     private ?Structure $structure = null;
  88.     #[ORM\Column]
  89.     private ?DateTimeImmutable $createdAt = null;
  91.     #[ORM\Column(nullable: true)]
  92.     private ?DateTimeImmutable $updatedAt = null;
  94.     #[ORM\ManyToOne(inversedBy: 'user')]
  95.     private ?Sectoral $sectoral = null;
  97.     #[ORM\Column(length: 255, nullable: true)]
  98.     #[Groups(['user:read', 'membre:read', 'meetParticipant:read'])]
  99.     private ?string $fonction = null;
  101.     private string $plainPassword;
  103.     #[ORM\ManyToMany(targetEntity: Decision::class, mappedBy: 'monitoringOfficer')]
  104.     private Collection $decisions;
  106.     #[ORM\Column(length: 255, nullable: true)]
  107.     #[Groups(['user:read', 'membre:read', 'meetParticipant:read'])]
  108.     private ?string $avatar = null;
  110.     #[ORM\Column(nullable: true)]
  111.     private ?\DateTimeImmutable $mailSentAt = null;
  113.     #[ORM\OneToMany(mappedBy: 'participants', targetEntity: MeetParticipant::class)]
  114.     private Collection $meetParticipants;
  116.     #[ORM\OneToMany(mappedBy: 'gestionnaire', targetEntity: Projet::class)]
  117.     private Collection $projets;
  119.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ProjetMembre::class)]
  120.     private Collection $projetMembres;
  122.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: TaskAssign::class)]
  123.     private Collection $taskAssigns;
  125.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Comment::class)]
  126.     private Collection $comments;
  128.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Bailleur::class)]
  129.     private Collection $bailleurs;
  131.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: CategorieProjet::class)]
  132.     private Collection $categorieProjets;
  134.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: ModeFinance::class)]
  135.     private Collection $modeFinances;
  137.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Priority::class)]
  138.     private Collection $priorities;
  140.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Structure::class)]
  141.     private Collection $structures;
  143.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: RateOfProgress::class)]
  144.     private Collection $rateOfProgress;
  146.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: RejectEvaluation::class)]
  147.     private Collection $rejectEvaluations;
  149.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Document::class)]
  150.     private Collection $documents;
  152.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Pao::class)]
  153.     private Collection $paos;
  155.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Objectif::class)]
  156.     private Collection $objectifs;
  158.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Activity::class)]
  159.     private Collection $activities;
  161.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Evaluation::class)]
  162.     private Collection $evaluations;
  164.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: EvaluationCritere::class)]
  165.     private Collection $evaluationCriteres;   
  167.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Meeting::class)]
  168.     private Collection $meetings;
  169.     
  171.     public function __construct()
  172.     {
  173.         $this->createdAt = new DateTimeImmutable();
  174.         $this->updatedAt = new DateTimeImmutable();
  175.         $this->decisions = new ArrayCollection();
  176.         $this->meetParticipants = new ArrayCollection();
  177.         $this->projets = new ArrayCollection();
  178.         $this->projetMembres = new ArrayCollection();
  179.         $this->taskAssigns = new ArrayCollection();
  180.         $this->comments = new ArrayCollection();
  181.         $this->bailleurs = new ArrayCollection();
  182.         $this->categorieProjets = new ArrayCollection();
  183.         $this->modeFinances = new ArrayCollection();
  184.         $this->priorities = new ArrayCollection();
  185.         $this->structures = new ArrayCollection();
  186.         $this->rateOfProgress = new ArrayCollection();
  187.         $this->rejectEvaluations = new ArrayCollection();
  188.         $this->documents = new ArrayCollection();
  189.         $this->paos = new ArrayCollection();
  190.         $this->objectifs = new ArrayCollection();
  191.         $this->activities = new ArrayCollection();
  192.         $this->evaluations = new ArrayCollection();
  193.         $this->evaluationCriteres = new ArrayCollection();
  194.         $this->meetings = new ArrayCollection();
  195.     }
  197.     public function getId(): ?int
  198.     {
  199.         return $this->id;
  200.     }
  202.     public function getMeetings(): Collection
  203.     {
  204.         return $this->meetings;
  205.     }
  207.     public function getEmail(): ?string
  208.     {
  209.         return $this->email;
  210.     }
  212.     public function setEmail(string $email): self
  213.     {
  214.         $this->email = $email;
  216.         return $this;
  217.     }
  219.     /**
  220.      * A visual identifier that represents this user.
  221.      *
  222.      * @see UserInterface
  223.      */
  224.     public function getUserIdentifier(): string
  225.     {
  226.         return (string) $this->email;
  227.     }
  229.     /**
  230.      * @see UserInterface
  231.      */
  232.     public function getRoles(): array
  233.     {
  234.         $roles = $this->roles;
  235.         // guarantee every user at least has ROLE_USER
  236.         $roles[] = 'ROLE_USER';
  238.         return array_unique($roles);
  239.     }
  241.     public function setRoles(array $roles): self
  242.     {
  243.         foreach ($roles as $role)
  244.         {
  245.             if(!str_starts_with($role, 'ROLE_') ||
  246.                 !in_array($role, ['ROLE_AGENT_MANAGER', 'ROLE_FONCTIONNAIRE', 'ROLE_MANAGER', 'ROLE_SUPERVISEUR']))
  247.             {
  248.                 throw new InvalidArgumentException("Le rôle doit être 'ROLE_FONCTIONNAIRE' ou 'ROLE_MANAGER' ou 'ROLE_SUPERVISEUR' ou commencé par ROLE_");
  249.             }
  250.         }
  252.         $this->roles = $roles;
  254.         return $this;
  255.     }
  257.     /**
  258.      * @see PasswordAuthenticatedUserInterface
  259.      */
  260.     public function getPassword(): string
  261.     {
  262.         return $this->password;
  263.     }
  265.     public function setPassword(string $password): self
  266.     {
  267.         $this->password = $password;
  269.         return $this;
  270.     }
  272.     /**
  273.      * @see UserInterface
  274.      */
  275.     public function eraseCredentials()
  276.     {
  277.         // If you store any temporary, sensitive data on the user, clear it here
  278.         // $this->plainPassword = null;
  279.     }
  281.     public function isVerified(): bool
  282.     {
  283.         return $this->isVerified;
  284.     }
  286.     public function setIsVerified(bool $isVerified): self
  287.     {
  288.         $this->isVerified = $isVerified;
  290.         return $this;
  291.     }
  293.     public function isIsEnabled(): ?bool
  294.     {
  295.         return $this->isEnabled;
  296.     }
  298.     public function setIsEnabled(bool $isEnabled): self
  299.     {
  300.         $this->isEnabled = $isEnabled;
  302.         return $this;
  303.     }
  305.     public function getGender(): ?string
  306.     {
  307.         return $this->gender;
  308.     }
  310.     public function setGender(string $gender): self
  311.     {
  312.         $this->gender = $gender;
  314.         return $this;
  315.     }
  317.     public function getFirstname(): ?string
  318.     {
  319.         return $this->firstname;
  320.     }
  322.     public function setFirstname(string $firstname): self
  323.     {
  324.         $this->firstname = $firstname;
  326.         return $this;
  327.     }
  329.     public function getLastname(): ?string
  330.     {
  331.         return $this->lastname;
  332.     }
  334.     public function setLastname(string $lastname): self
  335.     {
  336.         $this->lastname = $lastname;
  338.         return $this;
  339.     }
  341.     public function getPhone(): ?string
  342.     {
  343.         return $this->phone;
  344.     }
  346.     public function setPhone(string $phone): self
  347.     {
  348.         $this->phone = $phone;
  350.         return $this;
  351.     }
  353.     public function getLastLoginAt(): ?DateTimeImmutable
  354.     {
  355.         return $this->lastLoginAt;
  356.     }
  358.     public function setLastLoginAt(?DateTimeImmutable $lastLoginAt): self
  359.     {
  360.         $this->lastLoginAt = $lastLoginAt;
  362.         return $this;
  363.     }
  365.     public function getCreatedBy(): ?string
  366.     {
  367.         return $this->createdBy;
  368.     }
  370.     public function setCreatedBy(?string $createdBy): self
  371.     {
  372.         $this->createdBy = $createdBy;
  374.         return $this;
  375.     }
  377.     public function getUpdatedBy(): ?string
  378.     {
  379.         return $this->updatedBy;
  380.     }
  382.     public function setUpdatedBy(?string $updatedBy): self
  383.     {
  384.         $this->updatedBy = $updatedBy;
  386.         return $this;
  387.     }
  389.     public function isIsVerified(): ?bool
  390.     {
  391.         return $this->isVerified;
  392.     }
  394.     public function getAddress(): ?string
  395.     {
  396.         return $this->address;
  397.     }
  399.     public function setAddress(string $address): self
  400.     {
  401.         $this->address = $address;
  403.         return $this;
  404.     }
  406.     public function getDistrict(): ?string
  407.     {
  408.         return $this->district;
  409.     }
  411.     public function setDistrict(?string $district): self
  412.     {
  413.         $this->district = $district;
  415.         return $this;
  416.     }
  418.     /**
  419.      * @return mixed
  420.      */
  421.     public function getMunicipality(): mixed
  422.     {
  423.         return $this->municipality;
  424.     }
  426.     /**
  427.      * @param mixed $municipality
  428.      */
  429.     public function setMunicipality($municipality)
  430.     {
  431.         $this->municipality = $municipality;
  432.     }
  434.     public function getStructure(): ?Structure
  435.     {
  436.         return $this->structure;
  437.     }
  439.     public function setStructure(?Structure $structure): self
  440.     {
  441.         $this->structure = $structure;
  443.         return $this;
  444.     }
  446.     public function getCreatedAt(): ?DateTimeImmutable
  447.     {
  448.         return $this->createdAt;
  449.     }
  451.     public function setCreatedAt(DateTimeImmutable $createdAt): self
  452.     {
  453.         $this->createdAt = $createdAt;
  455.         return $this;
  456.     }
  458.     public function getUpdatedAt(): ?DateTimeImmutable
  459.     {
  460.         return $this->updatedAt;
  461.     }
  463.     public function setUpdatedAt(?DateTimeImmutable $updatedAt): self
  464.     {
  465.         $this->updatedAt = $updatedAt;
  467.         return $this;
  468.     }
  470.     public function getSectoral(): ?Sectoral
  471.     {
  472.         return $this->sectoral;
  473.     }
  475.     public function setSectoral(?Sectoral $sectoral): self
  476.     {
  477.         $this->sectoral = $sectoral;
  479.         return $this;
  480.     }
  483.     public function getFonction(): ?string
  484.     {
  485.         return $this->fonction;
  486.     }
  488.     public function setFonction(?string $fonction): self
  489.     {
  490.         $this->fonction = $fonction;
  492.         return $this;
  493.     }
  495.     /**
  496.      * @return string
  497.      */
  498.     public function getPlainPassword(): string
  499.     {
  500.         return $this->plainPassword;
  501.     }
  503.     /**
  504.      * @param string $plainPassword
  505.      */
  506.     public function setPlainPassword(string $plainPassword): void
  507.     {
  508.         $this->plainPassword = $plainPassword;
  509.     }
  511.     /**
  512.      * @return Collection<int, Decision>
  513.      */
  514.     public function getDecisions(): Collection
  515.     {
  516.         return $this->decisions;
  517.     }
  519.     public function addDecision(Decision $decision): self
  520.     {
  521.         if (!$this->decisions->contains($decision)) {
  522.             $this->decisions->add($decision);
  523.             $decision->addMonitoringOfficer($this);
  524.         }
  526.         return $this;
  527.     }
  529.     public function removeDecision(Decision $decision): self
  530.     {
  531.         if ($this->decisions->removeElement($decision)) {
  532.             $decision->removeMonitoringOfficer($this);
  533.         }
  535.         return $this;
  536.     }
  538.     public function getAvatar(): ?string
  539.     {
  540.         return $this->avatar;
  541.     }
  543.     public function setAvatar(?string $avatar): self
  544.     {
  545.         $this->avatar = $avatar;
  547.         return $this;
  548.     }
  550.     public function getMailSentAt(): ?\DateTimeImmutable
  551.     {
  552.         return $this->mailSentAt;
  553.     }
  555.     public function setMailSentAt(?\DateTimeImmutable $mailSentAt): self
  556.     {
  557.         $this->mailSentAt = $mailSentAt;
  559.         return $this;
  560.     }
  562.     /**
  563.      * @return Collection<int, MeetParticipant>
  564.      */
  565.     public function getMeetParticipants(): Collection
  566.     {
  567.         return $this->meetParticipants;
  568.     }
  570.     public function addMeetParticipant(MeetParticipant $meetParticipant): self
  571.     {
  572.         if (!$this->meetParticipants->contains($meetParticipant)) {
  573.             $this->meetParticipants->add($meetParticipant);
  574.             $meetParticipant->setParticipants($this);
  575.         }
  577.         return $this;
  578.     }
  580.     public function removeMeetParticipant(MeetParticipant $meetParticipant): self
  581.     {
  582.         if ($this->meetParticipants->removeElement($meetParticipant)) {
  583.             // set the owning side to null (unless already changed)
  584.             if ($meetParticipant->getParticipants() === $this) {
  585.                 $meetParticipant->setParticipants(null);
  586.             }
  587.         }
  589.         return $this;
  590.     }
  592.     public function __toString(): string 
  593.     {
  594.         return $this->firstname." ".$this->lastname." (".$this->phone.")";
  595.     }
  597.     /**
  598.      * @return Collection<int, Projet>
  599.      */
  600.     public function getProjets(): Collection
  601.     {
  602.         return $this->projets;
  603.     }
  605.     public function addProjet(Projet $projet): self
  606.     {
  607.         if (!$this->projets->contains($projet)) {
  608.             $this->projets->add($projet);
  609.             $projet->setGestionnaire($this);
  610.         }
  612.         return $this;
  613.     }
  615.     public function removeProjet(Projet $projet): self
  616.     {
  617.         if ($this->projets->removeElement($projet)) {
  618.             // set the owning side to null (unless already changed)
  619.             if ($projet->getGestionnaire() === $this) {
  620.                 $projet->setGestionnaire(null);
  621.             }
  622.         }
  624.         return $this;
  625.     }
  627.     /**
  628.      * @return Collection<int, ProjetMembre>
  629.      */
  630.     public function getProjetMembres(): Collection
  631.     {
  632.         return $this->projetMembres;
  633.     }
  635.     public function addProjetMembre(ProjetMembre $projetMembre): self
  636.     {
  637.         if (!$this->projetMembres->contains($projetMembre)) {
  638.             $this->projetMembres->add($projetMembre);
  639.             $projetMembre->setUser($this);
  640.         }
  642.         return $this;
  643.     }
  645.     public function removeProjetMembre(ProjetMembre $projetMembre): self
  646.     {
  647.         if ($this->projetMembres->removeElement($projetMembre)) {
  648.             // set the owning side to null (unless already changed)
  649.             if ($projetMembre->getUser() === $this) {
  650.                 $projetMembre->setUser(null);
  651.             }
  652.         }
  654.         return $this;
  655.     }
  657.     /**
  658.      * @return Collection<int, TaskAssign>
  659.      */
  660.     public function getTaskAssigns(): Collection
  661.     {
  662.         return $this->taskAssigns;
  663.     }
  665.     public function addTaskAssign(TaskAssign $taskAssign): self
  666.     {
  667.         if (!$this->taskAssigns->contains($taskAssign)) {
  668.             $this->taskAssigns->add($taskAssign);
  669.             $taskAssign->setUser($this);
  670.         }
  672.         return $this;
  673.     }
  675.     public function removeTaskAssign(TaskAssign $taskAssign): self
  676.     {
  677.         if ($this->taskAssigns->removeElement($taskAssign)) {
  678.             // set the owning side to null (unless already changed)
  679.             if ($taskAssign->getUser() === $this) {
  680.                 $taskAssign->setUser(null);
  681.             }
  682.         }
  684.         return $this;
  685.     }
  687.     /**
  688.      * @return Collection<int, Comment>
  689.      */
  690.     public function getComments(): Collection
  691.     {
  692.         return $this->comments;
  693.     }
  695.     public function addComment(Comment $comment): static
  696.     {
  697.         if (!$this->comments->contains($comment)) {
  698.             $this->comments->add($comment);
  699.             $comment->setAuthor($this);
  700.         }
  702.         return $this;
  703.     }
  705.     public function removeComment(Comment $comment): static
  706.     {
  707.         if ($this->comments->removeElement($comment)) {
  708.             // set the owning side to null (unless already changed)
  709.             if ($comment->getAuthor() === $this) {
  710.                 $comment->setAuthor(null);
  711.             }
  712.         }
  714.         return $this;
  715.     }
  717.     /**
  718.      * @return Collection<int, Bailleur>
  719.      */
  720.     public function getBailleurs(): Collection
  721.     {
  722.         return $this->bailleurs;
  723.     }
  725.     public function addBailleur(Bailleur $bailleur): static
  726.     {
  727.         if (!$this->bailleurs->contains($bailleur)) {
  728.             $this->bailleurs->add($bailleur);
  729.             $bailleur->setCreatedBy($this);
  730.         }
  732.         return $this;
  733.     }
  735.     public function removeBailleur(Bailleur $bailleur): static
  736.     {
  737.         if ($this->bailleurs->removeElement($bailleur)) {
  738.             // set the owning side to null (unless already changed)
  739.             if ($bailleur->getCreatedBy() === $this) {
  740.                 $bailleur->setCreatedBy(null);
  741.             }
  742.         }
  744.         return $this;
  745.     }
  747.     /**
  748.      * @return Collection<int, CategorieProjet>
  749.      */
  750.     public function getCategorieProjets(): Collection
  751.     {
  752.         return $this->categorieProjets;
  753.     }
  755.     public function addCategorieProjet(CategorieProjet $categorieProjet): static
  756.     {
  757.         if (!$this->categorieProjets->contains($categorieProjet)) {
  758.             $this->categorieProjets->add($categorieProjet);
  759.             $categorieProjet->setCreatedBy($this);
  760.         }
  762.         return $this;
  763.     }
  765.     public function removeCategorieProjet(CategorieProjet $categorieProjet): static
  766.     {
  767.         if ($this->categorieProjets->removeElement($categorieProjet)) {
  768.             // set the owning side to null (unless already changed)
  769.             if ($categorieProjet->getCreatedBy() === $this) {
  770.                 $categorieProjet->setCreatedBy(null);
  771.             }
  772.         }
  774.         return $this;
  775.     }
  777.     /**
  778.      * @return Collection<int, ModeFinance>
  779.      */
  780.     public function getModeFinances(): Collection
  781.     {
  782.         return $this->modeFinances;
  783.     }
  785.     public function addModeFinance(ModeFinance $modeFinance): static
  786.     {
  787.         if (!$this->modeFinances->contains($modeFinance)) {
  788.             $this->modeFinances->add($modeFinance);
  789.             $modeFinance->setCreatedBy($this);
  790.         }
  792.         return $this;
  793.     }
  795.     public function removeModeFinance(ModeFinance $modeFinance): static
  796.     {
  797.         if ($this->modeFinances->removeElement($modeFinance)) {
  798.             // set the owning side to null (unless already changed)
  799.             if ($modeFinance->getCreatedBy() === $this) {
  800.                 $modeFinance->setCreatedBy(null);
  801.             }
  802.         }
  804.         return $this;
  805.     }
  807.     /**
  808.      * @return Collection<int, Priority>
  809.      */
  810.     public function getPriorities(): Collection
  811.     {
  812.         return $this->priorities;
  813.     }
  815.     public function addPriority(Priority $priority): static
  816.     {
  817.         if (!$this->priorities->contains($priority)) {
  818.             $this->priorities->add($priority);
  819.             $priority->setCreatedBy($this);
  820.         }
  822.         return $this;
  823.     }
  825.     public function removePriority(Priority $priority): static
  826.     {
  827.         if ($this->priorities->removeElement($priority)) {
  828.             // set the owning side to null (unless already changed)
  829.             if ($priority->getCreatedBy() === $this) {
  830.                 $priority->setCreatedBy(null);
  831.             }
  832.         }
  834.         return $this;
  835.     }
  837.     /**
  838.      * @return Collection<int, Structure>
  839.      */
  840.     public function getStructures(): Collection
  841.     {
  842.         return $this->structures;
  843.     }
  845.     public function addStructure(Structure $structure): static
  846.     {
  847.         if (!$this->structures->contains($structure)) {
  848.             $this->structures->add($structure);
  849.             $structure->setCreatedBy($this);
  850.         }
  852.         return $this;
  853.     }
  855.     public function removeStructure(Structure $structure): static
  856.     {
  857.         if ($this->structures->removeElement($structure)) {
  858.             // set the owning side to null (unless already changed)
  859.             if ($structure->getCreatedBy() === $this) {
  860.                 $structure->setCreatedBy(null);
  861.             }
  862.         }
  864.         return $this;
  865.     }
  867.     /**
  868.      * @return Collection<int, RateOfProgress>
  869.      */
  870.     public function getRateOfProgress(): Collection
  871.     {
  872.         return $this->rateOfProgress;
  873.     }
  875.     public function addRateOfProgress(RateOfProgress $rateOfProgress): static
  876.     {
  877.         if (!$this->rateOfProgress->contains($rateOfProgress)) {
  878.             $this->rateOfProgress->add($rateOfProgress);
  879.             $rateOfProgress->setAuthor($this);
  880.         }
  882.         return $this;
  883.     }
  885.     public function removeRateOfProgress(RateOfProgress $rateOfProgress): static
  886.     {
  887.         if ($this->rateOfProgress->removeElement($rateOfProgress)) {
  888.             // set the owning side to null (unless already changed)
  889.             if ($rateOfProgress->getAuthor() === $this) {
  890.                 $rateOfProgress->setAuthor(null);
  891.             }
  892.         }
  894.         return $this;
  895.     }
  897.     /**
  898.      * @return Collection<int, RejectEvaluation>
  899.      */
  900.     public function getRejectEvaluations(): Collection
  901.     {
  902.         return $this->rejectEvaluations;
  903.     }
  905.     public function addRejectEvaluation(RejectEvaluation $rejectEvaluation): static
  906.     {
  907.         if (!$this->rejectEvaluations->contains($rejectEvaluation)) {
  908.             $this->rejectEvaluations->add($rejectEvaluation);
  909.             $rejectEvaluation->setAuthor($this);
  910.         }
  912.         return $this;
  913.     }
  915.     public function removeRejectEvaluation(RejectEvaluation $rejectEvaluation): static
  916.     {
  917.         if ($this->rejectEvaluations->removeElement($rejectEvaluation)) {
  918.             // set the owning side to null (unless already changed)
  919.             if ($rejectEvaluation->getAuthor() === $this) {
  920.                 $rejectEvaluation->setAuthor(null);
  921.             }
  922.         }
  924.         return $this;
  925.     }
  927.     /**
  928.      * @return Collection<int, Document>
  929.      */
  930.     public function getDocuments(): Collection
  931.     {
  932.         return $this->documents;
  933.     }
  935.     public function addDocument(Document $document): static
  936.     {
  937.         if (!$this->documents->contains($document)) {
  938.             $this->documents->add($document);
  939.             $document->setAuthor($this);
  940.         }
  942.         return $this;
  943.     }
  945.     public function removeDocument(Document $document): static
  946.     {
  947.         if ($this->documents->removeElement($document)) {
  948.             // set the owning side to null (unless already changed)
  949.             if ($document->getAuthor() === $this) {
  950.                 $document->setAuthor(null);
  951.             }
  952.         }
  954.         return $this;
  955.     }
  957.     /**
  958.      * @return Collection<int, Pao>
  959.      */
  960.     public function getPaos(): Collection
  961.     {
  962.         return $this->paos;
  963.     }
  965.     public function addPao(Pao $pao): static
  966.     {
  967.         if (!$this->paos->contains($pao)) {
  968.             $this->paos->add($pao);
  969.             $pao->setCreatedBy($this);
  970.         }
  972.         return $this;
  973.     }
  975.     public function removePao(Pao $pao): static
  976.     {
  977.         if ($this->paos->removeElement($pao)) {
  978.             // set the owning side to null (unless already changed)
  979.             if ($pao->getCreatedBy() === $this) {
  980.                 $pao->setCreatedBy(null);
  981.             }
  982.         }
  984.         return $this;
  985.     }
  987.     /**
  988.      * @return Collection<int, Objectif>
  989.      */
  990.     public function getObjectifs(): Collection
  991.     {
  992.         return $this->objectifs;
  993.     }
  995.     public function addObjectif(Objectif $objectif): static
  996.     {
  997.         if (!$this->objectifs->contains($objectif)) {
  998.             $this->objectifs->add($objectif);
  999.             $objectif->setCreatedBy($this);
  1000.         }
  1002.         return $this;
  1003.     }
  1005.     public function removeObjectif(Objectif $objectif): static
  1006.     {
  1007.         if ($this->objectifs->removeElement($objectif)) {
  1008.             // set the owning side to null (unless already changed)
  1009.             if ($objectif->getCreatedBy() === $this) {
  1010.                 $objectif->setCreatedBy(null);
  1011.             }
  1012.         }
  1014.         return $this;
  1015.     }
  1017.     /**
  1018.      * @return Collection<int, Activity>
  1019.      */
  1020.     public function getActivities(): Collection
  1021.     {
  1022.         return $this->activities;
  1023.     }
  1025.     public function addActivity(Activity $activity): static
  1026.     {
  1027.         if (!$this->activities->contains($activity)) {
  1028.             $this->activities->add($activity);
  1029.             $activity->setCreatedBy($this);
  1030.         }
  1032.         return $this;
  1033.     }
  1035.     public function removeActivity(Activity $activity): static
  1036.     {
  1037.         if ($this->activities->removeElement($activity)) {
  1038.             // set the owning side to null (unless already changed)
  1039.             if ($activity->getCreatedBy() === $this) {
  1040.                 $activity->setCreatedBy(null);
  1041.             }
  1042.         }
  1044.         return $this;
  1045.     }
  1047.     /**
  1048.      * @return Collection<int, Evaluation>
  1049.      */
  1050.     public function getEvaluations(): Collection
  1051.     {
  1052.         return $this->evaluations;
  1053.     }
  1055.     public function addEvaluation(Evaluation $evaluation): static
  1056.     {
  1057.         if (!$this->evaluations->contains($evaluation)) {
  1058.             $this->evaluations->add($evaluation);
  1059.             $evaluation->setCreatedBy($this);
  1060.         }
  1062.         return $this;
  1063.     }
  1065.     public function removeEvaluation(Evaluation $evaluation): static
  1066.     {
  1067.         if ($this->evaluations->removeElement($evaluation)) {
  1068.             // set the owning side to null (unless already changed)
  1069.             if ($evaluation->getCreatedBy() === $this) {
  1070.                 $evaluation->setCreatedBy(null);
  1071.             }
  1072.         }
  1074.         return $this;
  1075.     }
  1077.     /**
  1078.      * @return Collection<int, EvaluationCritere>
  1079.      */
  1080.     public function getEvaluationCriteres(): Collection
  1081.     {
  1082.         return $this->evaluationCriteres;
  1083.     }
  1085.     public function addEvaluationCritere(EvaluationCritere $evaluationCritere): static
  1086.     {
  1087.         if (!$this->evaluationCriteres->contains($evaluationCritere)) {
  1088.             $this->evaluationCriteres->add($evaluationCritere);
  1089.             $evaluationCritere->setCreatedBy($this);
  1090.         }
  1092.         return $this;
  1093.     }
  1095.     public function removeEvaluationCritere(EvaluationCritere $evaluationCritere): static
  1096.     {
  1097.         if ($this->evaluationCriteres->removeElement($evaluationCritere)) {
  1098.             // set the owning side to null (unless already changed)
  1099.             if ($evaluationCritere->getCreatedBy() === $this) {
  1100.                 $evaluationCritere->setCreatedBy(null);
  1101.             }
  1102.         }
  1104.         return $this;
  1105.     }
  1108.      // Méthode pour ajouter une réunion
  1109.      public function addMeeting(Meeting $meeting): void
  1110.      {
  1111.          if (!$this->meetings->contains($meeting)) {
  1112.              $this->meetings[] = $meeting;
  1113.              $meeting->setUser($this); // Associer l'utilisateur à la réunion
  1114.          }
  1115.      }
  1117.       // Méthode pour supprimer une réunion
  1118.     public function removeMeeting(Meeting $meeting): void
  1119.     {
  1120.         if ($this->meetings->contains($meeting)) {
  1121.             $this->meetings->removeElement($meeting);
  1122.             // Dissocier l'utilisateur de la réunion
  1123.             if ($meeting->getUser() === $this) {
  1124.                 $meeting->setUser(null);
  1125.             }
  1126.         }
  1127.     }
  1129. }