src/Entity/User.php line 20

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\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  13. use App\Entity\Traits\Timestampable;
  14. use JMS\Serializer\Annotation\Groups;
  16. #[ORM\HasLifecycleCallbacks]
  17. #[ORM\Entity(repositoryClass: UserRepository::class)]
  18. #[ORM\Table(name: '`user`')]
  19. #[UniqueEntity(fields: ['phone'], message: 'There is already an account with this email')]
  20. class User implements UserInterface, PasswordAuthenticatedUserInterface
  21. { 
  22.     
  23.     use Timestampable;
  24.     #[ORM\Id]
  25.     #[ORM\GeneratedValue]
  26.     #[ORM\Column]
  27.     #[Groups(['homework','getNews','getUserNotification','chatWebNew', 'chatView', 'chatAllList', 'singleMessage','getDiscussion','getStudents','getSubject','getAppUsers'])]
  28.     private ?int $id = null;
  30.     #[ORM\Column(length: 180, nullable: true)]
  31.     #[Groups(["getAppUsers","getUserNotification"])]
  32.     private ?string $email = null;
  34.     #[ORM\Column]
  35.     private array $roles = [];
  37.     /**
  38.      * @var string The hashed password
  39.      */
  40.     #[ORM\Column]
  41.     private ?string $password = null;
  43.     #[ORM\Column(length: 255, nullable: true)]
  44.     #[Groups(['chatWebNew', 'chatAllList','getDiscussion','getAppUsers','getUserNotification'])]
  45.     private ?string $firstName = null;
  47.     #[ORM\Column(length: 255, nullable: true)]
  48.     #[Groups(['chatWebNew', 'chatAllList','getDiscussion','getAppUsers','getUserNotification'])]
  49.     private ?string $lastName = null;
  51.     #[ORM\Column(length: 255)]
  52.     #[Groups(['getAppUsers'])]
  53.     private ?string $phone = null;
  55.     #[ORM\Column(length: 255)]
  56.     #[Groups(['chatWebNew','getDiscussion','getAppUsers','getUserNotification'])]
  57.     private ?string $userType = null;
  59.     #[ORM\Column(type: 'boolean')]
  60.     private $isVerified = false;
  62.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: News::class)]
  63.     private Collection $news;
  65.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Event::class)]
  66.     private Collection $events;
  68.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserYear::class)]
  69.     private Collection $userYears;
  71.     #[ORM\Column(length: 255, nullable: true)]
  72.     #[Groups(['getAppUsers'])]
  73.     private ?string $matricule = null;
  75.     #[ORM\OneToMany(mappedBy: 'prof', targetEntity: Subject::class)]
  76.     private Collection $subjects;
  78.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: Student::class)]
  79.     private Collection $students;
  81.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: HomeWork::class)]
  82.     private Collection $homeWorks;
  84.     #[ORM\OneToMany(mappedBy: 'initiator', targetEntity: Chat::class)]
  85.     private Collection $chats;
  87.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Message::class)]
  88.     private Collection $messages;
  90.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: DocInfo::class)]
  91.     private Collection $docInfos;
  93.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: DocInfo::class)]
  94.     private Collection $docInfoUpdated;
  96.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: DocInfo::class)]
  97.     private Collection $parentDocInfos;
  99.     #[ORM\OneToMany(mappedBy: 'userA', targetEntity: Discussion::class)]
  100.     private Collection $discussions;
  102.     #[ORM\OneToMany(mappedBy: 'messageBy', targetEntity: DiscussionMessage::class)]
  103.     private Collection $discussionMessages;
  105.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Notifications::class)]
  106.     private Collection $notifications;
  108.     #[ORM\Column(length: 255, nullable: true)]
  109.     private ?string $fullName = null;
  111.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Absence::class)]
  112.     private Collection $absences;
  114.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Absence::class)]
  115.     private Collection $absencesEdited;
  117.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: CategoryEvent::class)]
  118.     private Collection $categoryEvents;
  120.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: CategoryEvent::class)]
  121.     private Collection $categoryEventsEdited;
  123.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ClassYear::class)]
  124.     private Collection $classYears;
  126.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: ClassYear::class)]
  127.     private Collection $ClassYearsEdited;
  129.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Event::class)]
  130.     private Collection $eventsEdited;
  132.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Exams::class)]
  133.     private Collection $exams;
  135.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Exams::class)]
  136.     private Collection $examsEdited;
  138.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: HomeWork::class)]
  139.     private Collection $homeworksEdited;
  141.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Late::class)]
  142.     private Collection $lates;
  144.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Late::class)]
  145.     private Collection $latesEdited;
  147.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: NewsCategory::class)]
  148.     private Collection $newsCategories;
  150.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: NewsCategory::class)]
  151.     private Collection $newsCategoriesEdited;
  153.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Note::class)]
  154.     private Collection $notes;
  156.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Note::class)]
  157.     private Collection $notesEdited;
  159.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: SchoolSection::class)]
  160.     private Collection $schoolSections;
  162.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: SchoolSection::class)]
  163.     private Collection $schoolSectionsEdited;
  165.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: SchoolYear::class)]
  166.     private Collection $schoolYears;
  168.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: SchoolYear::class)]
  169.     private Collection $schoolYearsEdited;
  171.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Student::class)]
  172.     private Collection $studentsEdited;
  174.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Subject::class)]
  175.     private Collection $subjectsEdited;
  177.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: SubjectGroup::class)]
  178.     private Collection $subjectGroups;
  180.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: SubjectGroup::class)]
  181.     private Collection $subjectGroupsEdited;
  183.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: TheClass::class)]
  184.     private Collection $theClasses;
  186.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: TheClass::class)]
  187.     private Collection $theClassesEdited;
  189.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'users', cascade: ["persist"])]
  190.     private ?self $author = null;
  192.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: self::class)]
  193.     private Collection $users;
  195.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'usersEdited', cascade: ["persist"])]
  196.     private ?self $editor = null;
  198.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: self::class)]
  199.     private Collection $usersEdited;
  201.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Student::class)]
  202.     private Collection $studentsCreated;
  204.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Subject::class)]
  205.     private Collection $subjectsCreated;
  207.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: News::class)]
  208.     private Collection $newsEdited;
  209.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Punish::class)]
  210.     private Collection $punishes;
  212.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: PunishCategory::class)]
  213.     private Collection $punishCategories;
  215.     #[Groups(['getDiscussion'])]
  216.     #[ORM\Column(type: Types::BIGINT, nullable: true)]
  217.     private ?string $lastRequestTs = null;
  219.     #[ORM\ManyToOne(inversedBy: 'users', cascade: ["persist"])]
  220.     private ?School $school = null;
  222.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: DiscussionClassMessage::class)]
  223.     private Collection $discussionClassMessages;
  225.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Agenda::class)]
  226.     private Collection $agendas;
  228.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ExamAgenda::class)]
  229.     private Collection $examAgendas;
  231.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: SubSequence::class)]
  232.     private Collection $subSequences;
  234.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Quarter::class)]
  235.     private Collection $quarters;
  237.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: SubNote::class)]
  238.     private Collection $subNotes;
  240.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AgendaDay::class)]
  241.     private Collection $agendaDays;
  243.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AgendaElement::class)]
  244.     private Collection $agendaElements;
  246.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ExamAgendaDay::class)]
  247.     private Collection $examAgendaDays;
  249.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ExamAgendaElement::class)]
  250.     private Collection $examAgendaElements;
  252.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Appreciation::class)]
  253.     private Collection $appreciations;
  254.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: LocalAccount::class)]
  255.     private Collection $localAccounts;
  258.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: NewsBookmark::class)]
  259.     private Collection $newsBookmarks;
  261.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: HomeworkBookmark::class)]
  262.     private Collection $homeworkBookmarks;
  264.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ScolarityHistory::class)]
  265.     private Collection $scolarityHistories;
  267.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ScolarityHistoryEdition::class)]
  268.     private Collection $scolarityHistoryEditions;
  270.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: JustifyAbsence::class)]
  271.     private Collection $justifyAbsences;
  273.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: VerbalProcess::class)]
  274.     private Collection $verbalProcesses;
  276.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceDisciplineConcileConfig::class)]
  277.     private Collection $absenceDisciplineConcileConfigs;
  279.     #[ORM\OneToMany(mappedBy: 'prof', targetEntity: TheClass::class)]
  280.     private Collection $theClassesTeached;
  282.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: PrimaryNote::class)]
  283.     private Collection $primaryNotes;
  285.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: VerbalProcessCategory::class)]
  286.     private Collection $verbalProcessCategories;
  288.     #[ORM\Column(length: 255, nullable: true)]
  289.     private ?string $theme = null;
  291.     #[ORM\Column(length: 255, nullable: true)]
  292.     #[Groups(["getDiscussion"])]
  293.     private ?string $picture = null;
  295.     #[ORM\Column(length: 255, nullable: true)]
  296.     private ?string $sexe = null;
  298.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserAndroidToken::class)]
  299.     private Collection $userAndroidTokens;
  301.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserIphoneToken::class)]
  302.     private Collection $userIphoneTokens;
  304.     #[ORM\Column(length: 255, nullable: true)]
  305.     private ?string $localPhoneLang = null;
  307.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceBlameConfig::class)]
  308.     private Collection $absenceBlameConfigs;
  310.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceWarningConfig::class)]
  311.     private Collection $absenceWarningConfigs;
  313.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsencePunishConfig::class)]
  314.     private Collection $absencePunishConfigs;
  316.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceExclusionConfig::class)]
  317.     private Collection $absenceExclusionConfigs;
  319.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: GlobalDisciplineEnabledConfig::class)]
  320.     private Collection $globalDisciplineEnabledConfigs;
  322.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceRetainedConfig::class)]
  323.     private Collection $absenceRetainedConfigs;
  325.     #[ORM\Column(length: 255, nullable: true)]
  326.     private ?string $userToken = null;
  328.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: DisciplineConcile::class)]
  329.     private Collection $disciplineConciles;
  331.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserNotifications::class)]
  332.     private Collection $userNotifications;
  334.     #[ORM\OneToMany(mappedBy: 'prof', targetEntity: TimeTable::class)]
  335.     private Collection $timeTables;
  337.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: DiscussionMessagesCount::class, orphanRemoval: true)]
  338.     private Collection $discussionMessagesCounts;
  340.     public function __toString(): string
  341.     {
  342.         return $this->getFullName();
  343.     }
  345.     public function __construct()
  346.     {
  347.         $this->news = new ArrayCollection();
  348.         $this->events = new ArrayCollection();
  349.         $this->userYears = new ArrayCollection();
  350.         $this->subjects = new ArrayCollection();
  351.         $this->students = new ArrayCollection();
  352.         $this->homeWorks = new ArrayCollection();
  353.         $this->chats = new ArrayCollection();
  354.         $this->messages = new ArrayCollection();
  355.         $this->docInfos = new ArrayCollection();
  356.         $this->docInfoUpdated = new ArrayCollection();
  357.         $this->parentDocInfos = new ArrayCollection();
  358.         $this->discussions = new ArrayCollection();
  359.         $this->discussionMessages = new ArrayCollection();
  360.         $this->notifications = new ArrayCollection();
  361.         $this->absences = new ArrayCollection();
  362.         $this->absencesEdited = new ArrayCollection();
  363.         $this->categoryEvents = new ArrayCollection();
  364.         $this->categoryEventsEdited = new ArrayCollection();
  365.         $this->classYears = new ArrayCollection();
  366.         $this->ClassYearsEdited = new ArrayCollection();
  367.         $this->eventsEdited = new ArrayCollection();
  368.         $this->exams = new ArrayCollection();
  369.         $this->examsEdited = new ArrayCollection();
  370.         $this->homeworksEdited = new ArrayCollection();
  371.         $this->lates = new ArrayCollection();
  372.         $this->latesEdited = new ArrayCollection();
  373.         $this->newsCategories = new ArrayCollection();
  374.         $this->newsCategoriesEdited = new ArrayCollection();
  375.         $this->notes = new ArrayCollection();
  376.         $this->notesEdited = new ArrayCollection();
  377.         $this->schoolSections = new ArrayCollection();
  378.         $this->schoolSectionsEdited = new ArrayCollection();
  379.         $this->schoolYears = new ArrayCollection();
  380.         $this->schoolYearsEdited = new ArrayCollection();
  381.         $this->studentsEdited = new ArrayCollection();
  382.         $this->subjectsEdited = new ArrayCollection();
  383.         $this->subjectGroups = new ArrayCollection();
  384.         $this->subjectGroupsEdited = new ArrayCollection();
  385.         $this->theClasses = new ArrayCollection();
  386.         $this->theClassesEdited = new ArrayCollection();
  387.         $this->users = new ArrayCollection();
  388.         $this->usersEdited = new ArrayCollection();
  389.         $this->studentsCreated = new ArrayCollection();
  390.         $this->subjectsCreated = new ArrayCollection();
  391.         $this->newsEdited = new ArrayCollection();
  392.         $this->punishes = new ArrayCollection();
  393.         $this->punishCategories = new ArrayCollection();
  394.         $this->discussionClassMessages = new ArrayCollection();
  395.         $this->agendas = new ArrayCollection();
  396.         $this->examAgendas = new ArrayCollection();
  397.         $this->subSequences = new ArrayCollection();
  398.         $this->quarters = new ArrayCollection();
  399.         $this->subNotes = new ArrayCollection();
  400.         $this->agendaDays = new ArrayCollection();
  401.         $this->agendaElements = new ArrayCollection();
  402.         $this->examAgendaDays = new ArrayCollection();
  403.         $this->examAgendaElements = new ArrayCollection();
  404.         $this->appreciations = new ArrayCollection();
  405.         $this->localAccounts = new ArrayCollection();
  406.         $this->scolarityHistories = new ArrayCollection();
  407.         $this->scolarityHistoryEditions = new ArrayCollection();
  408.         $this->justifyAbsences = new ArrayCollection();
  409.         $this->verbalProcesses = new ArrayCollection();
  410.         $this->absenceDisciplineConcileConfigs = new ArrayCollection();
  411.         $this->theClassesTeached = new ArrayCollection();
  412.         $this->primaryNotes = new ArrayCollection();
  413.         $this->verbalProcessCategories = new ArrayCollection();
  414.         $this->newsBookmarks = new ArrayCollection();
  415.         $this->homeworkBookmarks = new ArrayCollection();
  416.         $this->userAndroidTokens = new ArrayCollection();
  417.         $this->userIphoneTokens = new ArrayCollection();
  418.         $this->absenceBlameConfigs = new ArrayCollection();
  419.         $this->absenceWarningConfigs = new ArrayCollection();
  420.         $this->absencePunishConfigs = new ArrayCollection();
  421.         $this->absenceExclusionConfigs = new ArrayCollection();
  422.         $this->globalDisciplineEnabledConfigs = new ArrayCollection();
  423.         $this->absenceRetainedConfigs = new ArrayCollection();
  424.         $this->disciplineConciles = new ArrayCollection();
  425.         $this->userNotifications = new ArrayCollection();
  426.         $this->timeTables = new ArrayCollection();
  427.         $this->discussionMessagesCounts = new ArrayCollection();
  428.     }
  430.     public function getFullName():string
  431.     {
  432.         return $this->getLastName()." ".$this->getFirstName();
  433.     }
  435.     public function getId(): ?int
  436.     {
  437.         return $this->id;
  438.     }
  440.     public function getEmail(): ?string
  441.     {
  442.         return $this->email;
  443.     }
  445.     public function setEmail(string $email): static
  446.     {
  447.         $this->email = $email;
  449.         return $this;
  450.     }
  452.     /**
  453.      * A visual identifier that represents this user.
  454.      *
  455.      * @see UserInterface
  456.      */
  457.     public function getUserIdentifier(): string
  458.     {
  459.         return (string) $this->email;
  460.     }
  462.     /**
  463.      * @see UserInterface
  464.      */
  465.     public function getRoles(): array
  466.     {
  467.         $roles = $this->roles;
  468.         // guarantee every user at least has ROLE_USER
  469.         $roles[] = 'ROLE_USER';
  471.         return array_unique($roles);
  472.     }
  474.     public function setRoles(array $roles): static
  475.     {
  476.         $this->roles = $roles;
  478.         return $this;
  479.     }
  481.     /**
  482.      * @see PasswordAuthenticatedUserInterface
  483.      */
  484.     public function getPassword(): string
  485.     {
  486.         return $this->password;
  487.     }
  489.     public function setPassword(string $password): static
  490.     {
  491.         $this->password = $password;
  493.         return $this;
  494.     }
  496.     /**
  497.      * @see UserInterface
  498.      */
  499.     public function eraseCredentials(): void
  500.     {
  501.         // If you store any temporary, sensitive data on the user, clear it here
  502.         // $this->plainPassword = null;
  503.     }
  505.     public function getFirstName(): ?string
  506.     {
  507.         return $this->firstName;
  508.     }
  510.     public function setFirstName(string $firstName): static
  511.     {
  512.         $this->firstName = $firstName;
  514.         return $this;
  515.     }
  517.     public function getLastName(): ?string
  518.     {
  519.         return $this->lastName;
  520.     }
  522.     public function setLastName(string $lastName): static
  523.     {
  524.         $this->lastName = $lastName;
  526.         return $this;
  527.     }
  529.     public function getPhone(): ?string
  530.     {
  531.         return $this->phone;
  532.     }
  534.     public function setPhone(string $phone): static
  535.     {
  536.         $this->phone = $phone;
  538.         return $this;
  539.     }
  541.     public function getUserType(): ?string
  542.     {
  543.         return $this->userType;
  544.     }
  546.     public function setUserType(string $userType): static
  547.     {
  548.         $this->userType = $userType;
  550.         return $this;
  551.     }
  553.     public function isVerified(): bool
  554.     {
  555.         return $this->isVerified;
  556.     }
  558.     public function setIsVerified(bool $isVerified): static
  559.     {
  560.         $this->isVerified = $isVerified;
  562.         return $this;
  563.     }
  565.     /**
  566.      * @return Collection<int, News>
  567.      */
  568.     public function getNews(): Collection
  569.     {
  570.         return $this->news;
  571.     }
  573.     public function addNews(News $news): static
  574.     {
  575.         if (!$this->news->contains($news)) {
  576.             $this->news->add($news);
  577.             $news->setAuthor($this);
  578.         }
  580.         return $this;
  581.     }
  583.     public function removeNews(News $news): static
  584.     {
  585.         if ($this->news->removeElement($news)) {
  586.             // set the owning side to null (unless already changed)
  587.             if ($news->getAuthor() === $this) {
  588.                 $news->setAuthor(null);
  589.             }
  590.         }
  592.         return $this;
  593.     }
  595.     /**
  596.      * @return Collection<int, Event>
  597.      */
  598.     public function getEvents(): Collection
  599.     {
  600.         return $this->events;
  601.     }
  603.     public function addEvent(Event $event): static
  604.     {
  605.         if (!$this->events->contains($event)) {
  606.             $this->events->add($event);
  607.             $event->setAuthor($this);
  608.         }
  610.         return $this;
  611.     }
  613.     public function removeEvent(Event $event): static
  614.     {
  615.         if ($this->events->removeElement($event)) {
  616.             // set the owning side to null (unless already changed)
  617.             if ($event->getAuthor() === $this) {
  618.                 $event->setAuthor(null);
  619.             }
  620.         }
  622.         return $this;
  623.     }
  625.     /**
  626.      * @return Collection<int, UserYear>
  627.      */
  628.     public function getUserYears(): Collection
  629.     {
  630.         return $this->userYears;
  631.     }
  633.     public function addUserYear(UserYear $userYear): static
  634.     {
  635.         if (!$this->userYears->contains($userYear)) {
  636.             $this->userYears->add($userYear);
  637.             $userYear->setUser($this);
  638.         }
  640.         return $this;
  641.     }
  643.     public function removeUserYear(UserYear $userYear): static
  644.     {
  645.         if ($this->userYears->removeElement($userYear)) {
  646.             // set the owning side to null (unless already changed)
  647.             if ($userYear->getUser() === $this) {
  648.                 $userYear->setUser(null);
  649.             }
  650.         }
  652.         return $this;
  653.     }
  655.     public function getMatricule(): ?string
  656.     {
  657.         return $this->matricule;
  658.     }
  660.     public function setMatricule(?string $matricule): static
  661.     {
  662.         $this->matricule = $matricule;
  664.         return $this;
  665.     }
  667.     /**
  668.      * @return Collection<int, Subject>
  669.      */
  670.     public function getSubjects(): Collection
  671.     {
  672.         return $this->subjects;
  673.     }
  675.     public function addSubject(Subject $subject): static
  676.     {
  677.         if (!$this->subjects->contains($subject)) {
  678.             $this->subjects->add($subject);
  679.             $subject->setProf($this);
  680.         }
  682.         return $this;
  683.     }
  685.     public function removeSubject(Subject $subject): static
  686.     {
  687.         if ($this->subjects->removeElement($subject)) {
  688.             // set the owning side to null (unless already changed)
  689.             if ($subject->getProf() === $this) {
  690.                 $subject->setProf(null);
  691.             }
  692.         }
  694.         return $this;
  695.     }
  697.     /**
  698.      * @return Collection<int, Student>
  699.      */
  700.     public function getStudents(): Collection
  701.     {
  702.         return $this->students;
  703.     }
  705.     public function addStudent(Student $student): static
  706.     {
  707.         if (!$this->students->contains($student)) {
  708.             $this->students->add($student);
  709.             $student->setParent($this);
  710.         }
  712.         return $this;
  713.     }
  715.     public function removeStudent(Student $student): static
  716.     {
  717.         if ($this->students->removeElement($student)) {
  718.             // set the owning side to null (unless already changed)
  719.             if ($student->getParent() === $this) {
  720.                 $student->setParent(null);
  721.             }
  722.         }
  724.         return $this;
  725.     }
  727.     /**
  728.      * @return Collection<int, HomeWork>
  729.      */
  730.     public function getHomeWorks(): Collection
  731.     {
  732.         return $this->homeWorks;
  733.     }
  735.     public function addHomeWork(HomeWork $homeWork): static
  736.     {
  737.         if (!$this->homeWorks->contains($homeWork)) {
  738.             $this->homeWorks->add($homeWork);
  739.             $homeWork->setAuthor($this);
  740.         }
  742.         return $this;
  743.     }
  745.     public function removeHomeWork(HomeWork $homeWork): static
  746.     {
  747.         if ($this->homeWorks->removeElement($homeWork)) {
  748.             // set the owning side to null (unless already changed)
  749.             if ($homeWork->getAuthor() === $this) {
  750.                 $homeWork->setAuthor(null);
  751.             }
  752.         }
  754.         return $this;
  755.     }
  757.     /**
  758.      * @return Collection<int, Chat>
  759.      */
  760.     public function getChats(): Collection
  761.     {
  762.         return $this->chats;
  763.     }
  765.     public function addChat(Chat $chat): static
  766.     {
  767.         if (!$this->chats->contains($chat)) {
  768.             $this->chats->add($chat);
  769.             $chat->setInitiator($this);
  770.         }
  772.         return $this;
  773.     }
  775.     public function removeChat(Chat $chat): static
  776.     {
  777.         if ($this->chats->removeElement($chat)) {
  778.             // set the owning side to null (unless already changed)
  779.             if ($chat->getInitiator() === $this) {
  780.                 $chat->setInitiator(null);
  781.             }
  782.         }
  784.         return $this;
  785.     }
  787.     /**
  788.      * @return Collection<int, Message>
  789.      */
  790.     public function getMessages(): Collection
  791.     {
  792.         return $this->messages;
  793.     }
  795.     public function addMessage(Message $message): static
  796.     {
  797.         if (!$this->messages->contains($message)) {
  798.             $this->messages->add($message);
  799.             $message->setAuthor($this);
  800.         }
  802.         return $this;
  803.     }
  805.     public function removeMessage(Message $message): static
  806.     {
  807.         if ($this->messages->removeElement($message)) {
  808.             // set the owning side to null (unless already changed)
  809.             if ($message->getAuthor() === $this) {
  810.                 $message->setAuthor(null);
  811.             }
  812.         }
  814.         return $this;
  815.     }
  817.     /* @return Collection<int, Discussion>
  818.     */
  819.     public function getDiscussions(): Collection
  820.     {
  821.         return $this->discussions;
  822.     }
  824.     public function addDiscussion(Discussion $discussion): static
  825.     {
  826.         if (!$this->discussions->contains($discussion)) {
  827.             $this->discussions->add($discussion);
  828.             $discussion->setUserA($this);
  829.         }
  831.         return $this;
  832.     }
  834.     public function removeDiscussion(Discussion $discussion): static
  835.     {
  836.         if ($this->discussions->removeElement($discussion)) {
  837.             // set the owning side to null (unless already changed)
  838.             if ($discussion->getUserA() === $this) {
  839.                 $discussion->setUserA(null);
  840.             }
  841.         }
  843.         return $this;
  844.     }
  846.     /**
  847.      * @return Collection<int, DocInfo>
  848.      */
  849.     public function getDocInfos(): Collection
  850.     {
  851.         return $this->docInfos;
  852.     }
  854.     public function addDocInfo(DocInfo $docInfo): static
  855.     {
  856.         if (!$this->docInfos->contains($docInfo)) {
  857.             $this->docInfos->add($docInfo);
  858.             $docInfo->setAuthor($this);
  859.         }
  861.         return $this;
  862.     }
  864.     public function removeDocInfo(DocInfo $docInfo): static
  865.     {
  866.         if ($this->docInfos->removeElement($docInfo)) {
  867.             // set the owning side to null (unless already changed)
  868.             if ($docInfo->getAuthor() === $this) {
  869.                 $docInfo->setAuthor(null);
  870.             }
  871.         }
  873.         return $this;
  874.     }
  876.     /**
  877.      * @return Collection<int, DocInfo>
  878.      */
  879.     public function getDocInfoUpdated(): Collection
  880.     {
  881.         return $this->docInfoUpdated;
  882.     }
  884.     public function addDocInfoUpdated(DocInfo $docInfoUpdated): static
  885.     {
  886.         if (!$this->docInfoUpdated->contains($docInfoUpdated)) {
  887.             $this->docInfoUpdated->add($docInfoUpdated);
  888.             $docInfoUpdated->setEditor($this);
  889.         }
  891.         return $this;
  892.     }
  894.     public function removeDocInfoUpdated(DocInfo $docInfoUpdated): static
  895.     {
  896.         if ($this->docInfoUpdated->removeElement($docInfoUpdated)) {
  897.             // set the owning side to null (unless already changed)
  898.             if ($docInfoUpdated->getEditor() === $this) {
  899.                 $docInfoUpdated->setEditor(null);
  900.             }
  901.         }
  902.         return $this;
  903.     }
  905.     /**
  906.      * @return Collection<int, DocInfo>
  907.      */
  908.     public function getParentDocInfos(): Collection
  909.     {
  910.         return $this->parentDocInfos;
  911.     }
  913.     public function addParentDocInfo(DocInfo $parentDocInfo): static
  914.     {
  915.         if (!$this->parentDocInfos->contains($parentDocInfo)) {
  916.             $this->parentDocInfos->add($parentDocInfo);
  917.             $parentDocInfo->setParent($this);
  918.         }
  920.         return $this;
  921.     }
  923.     public function removeParentDocInfo(DocInfo $parentDocInfo): static
  924.     {
  925.         if ($this->parentDocInfos->removeElement($parentDocInfo)) {
  926.             // set the owning side to null (unless already changed)
  927.             if ($parentDocInfo->getParent() === $this) {
  928.                 $parentDocInfo->setParent(null);
  929.             }
  930.         }
  932.         return $this;
  933.     }
  935.     /* @return Collection<int, DiscussionMessage>
  936.      */
  937.     public function getDiscussionMessages(): Collection
  938.     {
  939.         return $this->discussionMessages;
  940.     }
  942.     public function addDiscussionMessage(DiscussionMessage $discussionMessage): static
  943.     {
  944.         if (!$this->discussionMessages->contains($discussionMessage)) {
  945.             $this->discussionMessages->add($discussionMessage);
  946.             $discussionMessage->setMessageBy($this);
  947.         }
  949.         return $this;
  950.     }
  951.     public function removeDiscussionMessage(DiscussionMessage $discussionMessage): static
  952.     {
  953.         if ($this->discussionMessages->removeElement($discussionMessage)) {
  954.             // set the owning side to null (unless already changed)
  955.             if ($discussionMessage->getMessageBy() === $this) {
  956.                 $discussionMessage->setMessageBy(null);
  957.             }
  958.         }
  960.         return $this;
  961.     }
  963.     /* @return Collection<int, Notifications>
  964.      */
  965.     public function getNotifications(): Collection
  966.     {
  967.         return $this->notifications;
  968.     }
  970.     public function addNotification(Notifications $notification): static
  971.     {
  972.         if (!$this->notifications->contains($notification)) {
  973.             $this->notifications->add($notification);
  974.             $notification->setUser($this);
  975.         }
  977.         return $this;
  978.     }
  979.     public function removeNotification(Notifications $notification): static
  980.     {
  981.         if ($this->notifications->removeElement($notification)) {
  982.             // set the owning side to null (unless already changed)
  983.             if ($notification->getUser() === $this) {
  984.                 $notification->setUser(null);
  985.             }
  986.         }
  988.         return $this;
  989.     }
  991.     public function setFullName(?string $fullName): static
  992.     {
  993.         $this->fullName = $fullName;
  995.         return $this;
  996.     }
  998.     /**
  999.      * @return Collection<int, Absence>
  1000.      */
  1001.     public function getAbsences(): Collection
  1002.     {
  1003.         return $this->absences;
  1004.     }
  1006.     public function addAbsence(Absence $absence): static
  1007.     {
  1008.         if (!$this->absences->contains($absence)) {
  1009.             $this->absences->add($absence);
  1010.             $absence->setAuthor($this);
  1011.         }
  1012.         
  1013.         return $this;
  1014.     }
  1016.     /* @return Collection<int, Punish>
  1017.      */
  1018.     public function getPunishes(): Collection
  1019.     {
  1020.         return $this->punishes;
  1021.     }
  1023.     public function addPunish(Punish $punish): static
  1024.     {
  1025.         if (!$this->punishes->contains($punish)) {
  1026.             $this->punishes->add($punish);
  1027.             $punish->setAuthor($this);
  1028.         }
  1030.         return $this;
  1031.     }
  1032.     
  1033.     public function removePunish(Punish $punish): static
  1034.     {
  1035.         if ($this->punishes->removeElement($punish)) {
  1036.             // set the owning side to null (unless already changed)
  1037.             if ($punish->getAuthor() === $this) {
  1038.                 $punish->setAuthor(null);
  1039.             }
  1040.         }
  1042.         return $this;
  1043.     }
  1045.     public function removeAbsence(Absence $absence): static
  1046.     {
  1047.         if ($this->absences->removeElement($absence)) {
  1048.             // set the owning side to null (unless already changed)
  1049.             if ($absence->getAuthor() === $this) {
  1050.                 $absence->setAuthor(null);
  1051.             }
  1052.         }
  1054.         return $this;
  1055.     }
  1057.     /**
  1058.      * @return Collection<int, Absence>
  1059.      */
  1060.     public function getAbsencesEdited(): Collection
  1061.     {
  1062.         return $this->absencesEdited;
  1063.     }
  1065.     public function addAbsencesEdited(Absence $absencesEdited): static
  1066.     {
  1067.         if (!$this->absencesEdited->contains($absencesEdited)) {
  1068.             $this->absencesEdited->add($absencesEdited);
  1069.             $absencesEdited->setEditor($this);
  1070.         }
  1072.         return $this;
  1073.     }
  1075.     public function removeAbsencesEdited(Absence $absencesEdited): static
  1076.     {
  1077.         if ($this->absencesEdited->removeElement($absencesEdited)) {
  1078.             // set the owning side to null (unless already changed)
  1079.             if ($absencesEdited->getEditor() === $this) {
  1080.                 $absencesEdited->setEditor(null);
  1081.             }
  1082.         }
  1084.         return $this;
  1085.     }
  1087.     /**
  1088.      * @return Collection<int, CategoryEvent>
  1089.      */
  1090.     public function getCategoryEvents(): Collection
  1091.     {
  1092.         return $this->categoryEvents;
  1093.     }
  1095.     public function addCategoryEvent(CategoryEvent $categoryEvent): static
  1096.     {
  1097.         if (!$this->categoryEvents->contains($categoryEvent)) {
  1098.             $this->categoryEvents->add($categoryEvent);
  1099.             $categoryEvent->setAuthor($this);
  1100.         }
  1102.         return $this;
  1103.     }
  1105.     public function removeCategoryEvent(CategoryEvent $categoryEvent): static
  1106.     {
  1107.         if ($this->categoryEvents->removeElement($categoryEvent)) {
  1108.             // set the owning side to null (unless already changed)
  1109.             if ($categoryEvent->getAuthor() === $this) {
  1110.                 $categoryEvent->setAuthor(null);
  1111.             }
  1112.         }
  1114.         return $this;
  1115.     }
  1117.     /**
  1118.      * @return Collection<int, CategoryEvent>
  1119.      */
  1120.     public function getCategoryEventsEdited(): Collection
  1121.     {
  1122.         return $this->categoryEventsEdited;
  1123.     }
  1125.     public function addCategoryEventsEdited(CategoryEvent $categoryEventsEdited): static
  1126.     {
  1127.         if (!$this->categoryEventsEdited->contains($categoryEventsEdited)) {
  1128.             $this->categoryEventsEdited->add($categoryEventsEdited);
  1129.             $categoryEventsEdited->setEditor($this);
  1130.         }
  1132.         return $this;
  1133.     }
  1135.     public function removeCategoryEventsEdited(CategoryEvent $categoryEventsEdited): static
  1136.     {
  1137.         if ($this->categoryEventsEdited->removeElement($categoryEventsEdited)) {
  1138.             // set the owning side to null (unless already changed)
  1139.             if ($categoryEventsEdited->getEditor() === $this) {
  1140.                 $categoryEventsEdited->setEditor(null);
  1141.             }
  1142.         }
  1144.         return $this;
  1145.     }
  1147.     /**
  1148.      * @return Collection<int, ClassYear>
  1149.      */
  1150.     public function getClassYears(): Collection
  1151.     {
  1152.         return $this->classYears;
  1153.     }
  1155.     public function addClassYear(ClassYear $classYear): static
  1156.     {
  1157.         if (!$this->classYears->contains($classYear)) {
  1158.             $this->classYears->add($classYear);
  1159.             $classYear->setAuthor($this);
  1160.         }
  1162.         return $this;
  1163.     }
  1165.     public function removeClassYear(ClassYear $classYear): static
  1166.     {
  1167.         if ($this->classYears->removeElement($classYear)) {
  1168.             // set the owning side to null (unless already changed)
  1169.             if ($classYear->getAuthor() === $this) {
  1170.                 $classYear->setAuthor(null);
  1171.             }
  1172.         }
  1174.         return $this;
  1175.     }
  1177.     /**
  1178.      * @return Collection<int, ClassYear>
  1179.      */
  1180.     public function getClassYearsEdited(): Collection
  1181.     {
  1182.         return $this->ClassYearsEdited;
  1183.     }
  1185.     public function addClassYearsEdited(ClassYear $classYearsEdited): static
  1186.     {
  1187.         if (!$this->ClassYearsEdited->contains($classYearsEdited)) {
  1188.             $this->ClassYearsEdited->add($classYearsEdited);
  1189.             $classYearsEdited->setEditor($this);
  1190.         }
  1192.         return $this;
  1193.     }
  1195.     public function removeClassYearsEdited(ClassYear $classYearsEdited): static
  1196.     {
  1197.         if ($this->ClassYearsEdited->removeElement($classYearsEdited)) {
  1198.             // set the owning side to null (unless already changed)
  1199.             if ($classYearsEdited->getEditor() === $this) {
  1200.                 $classYearsEdited->setEditor(null);
  1201.             }
  1202.         }
  1204.         return $this;
  1205.     }
  1207.     /**
  1208.      * @return Collection<int, Event>
  1209.      */
  1210.     public function getEventsEdited(): Collection
  1211.     {
  1212.         return $this->eventsEdited;
  1213.     }
  1215.     public function addEventsEdited(Event $eventsEdited): static
  1216.     {
  1217.         if (!$this->eventsEdited->contains($eventsEdited)) {
  1218.             $this->eventsEdited->add($eventsEdited);
  1219.             $eventsEdited->setEditor($this);
  1220.         }
  1222.         return $this;
  1223.     }
  1225.     public function removeEventsEdited(Event $eventsEdited): static
  1226.     {
  1227.         if ($this->eventsEdited->removeElement($eventsEdited)) {
  1228.             // set the owning side to null (unless already changed)
  1229.             if ($eventsEdited->getEditor() === $this) {
  1230.                 $eventsEdited->setEditor(null);
  1231.             }
  1232.         }
  1234.         return $this;
  1235.     }
  1237.     /**
  1238.      * @return Collection<int, Exams>
  1239.      */
  1240.     public function getExams(): Collection
  1241.     {
  1242.         return $this->exams;
  1243.     }
  1245.     public function addExam(Exams $exam): static
  1246.     {
  1247.         if (!$this->exams->contains($exam)) {
  1248.             $this->exams->add($exam);
  1249.             $exam->setAuthor($this);
  1250.         }
  1252.         return $this;
  1253.     }
  1255.     public function removeExam(Exams $exam): static
  1256.     {
  1257.         if ($this->exams->removeElement($exam)) {
  1258.             // set the owning side to null (unless already changed)
  1259.             if ($exam->getAuthor() === $this) {
  1260.                 $exam->setAuthor(null);
  1261.             }
  1262.         }
  1264.         return $this;
  1265.     }
  1267.     /**
  1268.      * @return Collection<int, Exams>
  1269.      */
  1270.     public function getExamsEdited(): Collection
  1271.     {
  1272.         return $this->examsEdited;
  1273.     }
  1275.     public function addExamsEdited(Exams $examsEdited): static
  1276.     {
  1277.         if (!$this->examsEdited->contains($examsEdited)) {
  1278.             $this->examsEdited->add($examsEdited);
  1279.             $examsEdited->setEditor($this);
  1280.         }
  1282.         return $this;
  1283.     }
  1285.     public function removeExamsEdited(Exams $examsEdited): static
  1286.     {
  1287.         if ($this->examsEdited->removeElement($examsEdited)) {
  1288.             // set the owning side to null (unless already changed)
  1289.             if ($examsEdited->getEditor() === $this) {
  1290.                 $examsEdited->setEditor(null);
  1291.             }
  1292.         }
  1294.         return $this;
  1295.     }
  1297.     /**
  1298.      * @return Collection<int, HomeWork>
  1299.      */
  1300.     public function getHomeworksEdited(): Collection
  1301.     {
  1302.         return $this->homeworksEdited;
  1303.     }
  1305.     public function addHomeworksEdited(HomeWork $homeworksEdited): static
  1306.     {
  1307.         if (!$this->homeworksEdited->contains($homeworksEdited)) {
  1308.             $this->homeworksEdited->add($homeworksEdited);
  1309.             $homeworksEdited->setEditor($this);
  1310.         }
  1312.         return $this;
  1313.     }
  1315.     public function removeHomeworksEdited(HomeWork $homeworksEdited): static
  1316.     {
  1317.         if ($this->homeworksEdited->removeElement($homeworksEdited)) {
  1318.             // set the owning side to null (unless already changed)
  1319.             if ($homeworksEdited->getEditor() === $this) {
  1320.                 $homeworksEdited->setEditor(null);
  1321.             }
  1322.         }
  1324.         return $this;
  1325.     }
  1327.     /**
  1328.      * @return Collection<int, Late>
  1329.      */
  1330.     public function getLates(): Collection
  1331.     {
  1332.         return $this->lates;
  1333.     }
  1335.     public function addLate(Late $late): static
  1336.     {
  1337.         if (!$this->lates->contains($late)) {
  1338.             $this->lates->add($late);
  1339.             $late->setAuthor($this);
  1340.         }
  1342.         return $this;
  1343.     }
  1345.     public function removeLate(Late $late): static
  1346.     {
  1347.         if ($this->lates->removeElement($late)) {
  1348.             // set the owning side to null (unless already changed)
  1349.             if ($late->getAuthor() === $this) {
  1350.                 $late->setAuthor(null);
  1351.             }
  1352.         }
  1354.         return $this;
  1355.     }
  1357.     /**
  1358.      * @return Collection<int, Late>
  1359.      */
  1360.     public function getLatesEdited(): Collection
  1361.     {
  1362.         return $this->latesEdited;
  1363.     }
  1365.     public function addLatesEdited(Late $latesEdited): static
  1366.     {
  1367.         if (!$this->latesEdited->contains($latesEdited)) {
  1368.             $this->latesEdited->add($latesEdited);
  1369.             $latesEdited->setEditor($this);
  1370.         }
  1372.         return $this;
  1373.     }
  1375.     public function removeLatesEdited(Late $latesEdited): static
  1376.     {
  1377.         if ($this->latesEdited->removeElement($latesEdited)) {
  1378.             // set the owning side to null (unless already changed)
  1379.             if ($latesEdited->getEditor() === $this) {
  1380.                 $latesEdited->setEditor(null);
  1381.             }
  1382.         }
  1384.         return $this;
  1385.     }
  1387.     /**
  1388.      * @return Collection<int, NewsCategory>
  1389.      */
  1390.     public function getNewsCategories(): Collection
  1391.     {
  1392.         return $this->newsCategories;
  1393.     }
  1395.     public function addNewsCategory(NewsCategory $newsCategory): static
  1396.     {
  1397.         if (!$this->newsCategories->contains($newsCategory)) {
  1398.             $this->newsCategories->add($newsCategory);
  1399.             $newsCategory->setAuthor($this);
  1400.         }
  1402.         return $this;
  1403.     }
  1405.     public function removeNewsCategory(NewsCategory $newsCategory): static
  1406.     {
  1407.         if ($this->newsCategories->removeElement($newsCategory)) {
  1408.             // set the owning side to null (unless already changed)
  1409.             if ($newsCategory->getAuthor() === $this) {
  1410.                 $newsCategory->setAuthor(null);
  1411.             }
  1412.         }
  1414.         return $this;
  1415.     }
  1417.     /**
  1418.      * @return Collection<int, NewsCategory>
  1419.      */
  1420.     public function getNewsCategoriesEdited(): Collection
  1421.     {
  1422.         return $this->newsCategoriesEdited;
  1423.     }
  1425.     public function addNewsCategoriesEdited(NewsCategory $newsCategoriesEdited): static
  1426.     {
  1427.         if (!$this->newsCategoriesEdited->contains($newsCategoriesEdited)) {
  1428.             $this->newsCategoriesEdited->add($newsCategoriesEdited);
  1429.             $newsCategoriesEdited->setEditor($this);
  1430.         }
  1432.         return $this;
  1433.     }
  1435.     public function removeNewsCategoriesEdited(NewsCategory $newsCategoriesEdited): static
  1436.     {
  1437.         if ($this->newsCategoriesEdited->removeElement($newsCategoriesEdited)) {
  1438.             // set the owning side to null (unless already changed)
  1439.             if ($newsCategoriesEdited->getEditor() === $this) {
  1440.                 $newsCategoriesEdited->setEditor(null);
  1441.             }
  1442.         }
  1444.         return $this;
  1445.     }
  1447.     /**
  1448.      * @return Collection<int, Note>
  1449.      */
  1450.     public function getNotes(): Collection
  1451.     {
  1452.         return $this->notes;
  1453.     }
  1455.     public function addNote(Note $note): static
  1456.     {
  1457.         if (!$this->notes->contains($note)) {
  1458.             $this->notes->add($note);
  1459.             $note->setAuthor($this);
  1460.         }
  1462.         return $this;
  1463.     }
  1465.     public function removeNote(Note $note): static
  1466.     {
  1467.         if ($this->notes->removeElement($note)) {
  1468.             // set the owning side to null (unless already changed)
  1469.             if ($note->getAuthor() === $this) {
  1470.                 $note->setAuthor(null);
  1471.             }
  1472.         }
  1474.         return $this;
  1475.     }
  1477.     /**
  1478.      * @return Collection<int, Note>
  1479.      */
  1480.     public function getNotesEdited(): Collection
  1481.     {
  1482.         return $this->notesEdited;
  1483.     }
  1485.     public function addNotesEdited(Note $notesEdited): static
  1486.     {
  1487.         if (!$this->notesEdited->contains($notesEdited)) {
  1488.             $this->notesEdited->add($notesEdited);
  1489.             $notesEdited->setEditor($this);
  1490.         }
  1492.         return $this;
  1493.     }
  1495.     public function removeNotesEdited(Note $notesEdited): static
  1496.     {
  1497.         if ($this->notesEdited->removeElement($notesEdited)) {
  1498.             // set the owning side to null (unless already changed)
  1499.             if ($notesEdited->getEditor() === $this) {
  1500.                 $notesEdited->setEditor(null);
  1501.             }
  1502.         }
  1504.         return $this;
  1505.     }
  1507.     /**
  1508.      * @return Collection<int, SchoolSection>
  1509.      */
  1510.     public function getSchoolSections(): Collection
  1511.     {
  1512.         return $this->schoolSections;
  1513.     }
  1515.     public function addSchoolSection(SchoolSection $schoolSection): static
  1516.     {
  1517.         if (!$this->schoolSections->contains($schoolSection)) {
  1518.             $this->schoolSections->add($schoolSection);
  1519.             $schoolSection->setAuthor($this);
  1520.         }
  1522.         return $this;
  1523.     }
  1525.     public function removeSchoolSection(SchoolSection $schoolSection): static
  1526.     {
  1527.         if ($this->schoolSections->removeElement($schoolSection)) {
  1528.             // set the owning side to null (unless already changed)
  1529.             if ($schoolSection->getAuthor() === $this) {
  1530.                 $schoolSection->setAuthor(null);
  1531.             }
  1532.         }
  1534.         return $this;
  1535.     }
  1537.     /**
  1538.      * @return Collection<int, SchoolSection>
  1539.      */
  1540.     public function getSchoolSectionsEdited(): Collection
  1541.     {
  1542.         return $this->schoolSectionsEdited;
  1543.     }
  1545.     public function addSchoolSectionsEdited(SchoolSection $schoolSectionsEdited): static
  1546.     {
  1547.         if (!$this->schoolSectionsEdited->contains($schoolSectionsEdited)) {
  1548.             $this->schoolSectionsEdited->add($schoolSectionsEdited);
  1549.             $schoolSectionsEdited->setEditor($this);
  1550.         }
  1552.         return $this;
  1553.     }
  1555.     public function removeSchoolSectionsEdited(SchoolSection $schoolSectionsEdited): static
  1556.     {
  1557.         if ($this->schoolSectionsEdited->removeElement($schoolSectionsEdited)) {
  1558.             // set the owning side to null (unless already changed)
  1559.             if ($schoolSectionsEdited->getEditor() === $this) {
  1560.                 $schoolSectionsEdited->setEditor(null);
  1561.             }
  1562.         }
  1564.         return $this;
  1565.     }
  1567.     /**
  1568.      * @return Collection<int, SchoolYear>
  1569.      */
  1570.     public function getSchoolYears(): Collection
  1571.     {
  1572.         return $this->schoolYears;
  1573.     }
  1575.     public function addSchoolYear(SchoolYear $schoolYear): static
  1576.     {
  1577.         if (!$this->schoolYears->contains($schoolYear)) {
  1578.             $this->schoolYears->add($schoolYear);
  1579.             $schoolYear->setAuthor($this);
  1580.         }
  1582.         return $this;
  1583.     }
  1585.     public function removeSchoolYear(SchoolYear $schoolYear): static
  1586.     {
  1587.         if ($this->schoolYears->removeElement($schoolYear)) {
  1588.             // set the owning side to null (unless already changed)
  1589.             if ($schoolYear->getAuthor() === $this) {
  1590.                 $schoolYear->setAuthor(null);
  1591.             }
  1592.         }
  1594.         return $this;
  1595.     }
  1597.     /**
  1598.      * @return Collection<int, SchoolYear>
  1599.      */
  1600.     public function getSchoolYearsEdited(): Collection
  1601.     {
  1602.         return $this->schoolYearsEdited;
  1603.     }
  1605.     public function addSchoolYearsEdited(SchoolYear $schoolYearsEdited): static
  1606.     {
  1607.         if (!$this->schoolYearsEdited->contains($schoolYearsEdited)) {
  1608.             $this->schoolYearsEdited->add($schoolYearsEdited);
  1609.             $schoolYearsEdited->setEditor($this);
  1610.         }
  1612.         return $this;
  1613.     }
  1615.     public function removeSchoolYearsEdited(SchoolYear $schoolYearsEdited): static
  1616.     {
  1617.         if ($this->schoolYearsEdited->removeElement($schoolYearsEdited)) {
  1618.             // set the owning side to null (unless already changed)
  1619.             if ($schoolYearsEdited->getEditor() === $this) {
  1620.                 $schoolYearsEdited->setEditor(null);
  1621.             }
  1622.         }
  1624.         return $this;
  1625.     }
  1627.     /**
  1628.      * @return Collection<int, Student>
  1629.      */
  1630.     public function getStudentsEdited(): Collection
  1631.     {
  1632.         return $this->studentsEdited;
  1633.     }
  1635.     public function addStudentsEdited(Student $studentsEdited): static
  1636.     {
  1637.         if (!$this->studentsEdited->contains($studentsEdited)) {
  1638.             $this->studentsEdited->add($studentsEdited);
  1639.             $studentsEdited->setEditor($this);
  1640.         }
  1642.         return $this;
  1643.     }
  1645.     public function removeStudentsEdited(Student $studentsEdited): static
  1646.     {
  1647.         if ($this->studentsEdited->removeElement($studentsEdited)) {
  1648.             // set the owning side to null (unless already changed)
  1649.             if ($studentsEdited->getEditor() === $this) {
  1650.                 $studentsEdited->setEditor(null);
  1651.             }
  1652.         }
  1654.         return $this;
  1655.     }
  1657.     /**
  1658.      * @return Collection<int, Subject>
  1659.      */
  1660.     public function getSubjectsEdited(): Collection
  1661.     {
  1662.         return $this->subjectsEdited;
  1663.     }
  1665.     public function addSubjectsEdited(Subject $subjectsEdited): static
  1666.     {
  1667.         if (!$this->subjectsEdited->contains($subjectsEdited)) {
  1668.             $this->subjectsEdited->add($subjectsEdited);
  1669.             $subjectsEdited->setEditor($this);
  1670.         }
  1672.         return $this;
  1673.     }
  1675.     public function removeSubjectsEdited(Subject $subjectsEdited): static
  1676.     {
  1677.         if ($this->subjectsEdited->removeElement($subjectsEdited)) {
  1678.             // set the owning side to null (unless already changed)
  1679.             if ($subjectsEdited->getEditor() === $this) {
  1680.                 $subjectsEdited->setEditor(null);
  1681.             }
  1682.         }
  1684.         return $this;
  1685.     }
  1687.     /**
  1688.      * @return Collection<int, SubjectGroup>
  1689.      */
  1690.     public function getSubjectGroups(): Collection
  1691.     {
  1692.         return $this->subjectGroups;
  1693.     }
  1695.     public function addSubjectGroup(SubjectGroup $subjectGroup): static
  1696.     {
  1697.         if (!$this->subjectGroups->contains($subjectGroup)) {
  1698.             $this->subjectGroups->add($subjectGroup);
  1699.             $subjectGroup->setAuthor($this);
  1700.         }
  1702.         return $this;
  1703.     }
  1705.     public function removeSubjectGroup(SubjectGroup $subjectGroup): static
  1706.     {
  1707.         if ($this->subjectGroups->removeElement($subjectGroup)) {
  1708.             // set the owning side to null (unless already changed)
  1709.             if ($subjectGroup->getAuthor() === $this) {
  1710.                 $subjectGroup->setAuthor(null);
  1711.             }
  1712.         }
  1714.         return $this;
  1715.     }
  1717.     /**
  1718.      * @return Collection<int, SubjectGroup>
  1719.      */
  1720.     public function getSubjectGroupsEdited(): Collection
  1721.     {
  1722.         return $this->subjectGroupsEdited;
  1723.     }
  1725.     public function addSubjectGroupsEdited(SubjectGroup $subjectGroupsEdited): static
  1726.     {
  1727.         if (!$this->subjectGroupsEdited->contains($subjectGroupsEdited)) {
  1728.             $this->subjectGroupsEdited->add($subjectGroupsEdited);
  1729.             $subjectGroupsEdited->setEditor($this);
  1730.         }
  1732.         return $this;
  1733.     }
  1735.     public function removeSubjectGroupsEdited(SubjectGroup $subjectGroupsEdited): static
  1736.     {
  1737.         if ($this->subjectGroupsEdited->removeElement($subjectGroupsEdited)) {
  1738.             // set the owning side to null (unless already changed)
  1739.             if ($subjectGroupsEdited->getEditor() === $this) {
  1740.                 $subjectGroupsEdited->setEditor(null);
  1741.             }
  1742.         }
  1744.         return $this;
  1745.     }
  1747.     /**
  1748.      * @return Collection<int, TheClass>
  1749.      */
  1750.     public function getTheClasses(): Collection
  1751.     {
  1752.         return $this->theClasses;
  1753.     }
  1755.     public function addTheClass(TheClass $theClass): static
  1756.     {
  1757.         if (!$this->theClasses->contains($theClass)) {
  1758.             $this->theClasses->add($theClass);
  1759.             $theClass->setAuthor($this);
  1760.         }
  1762.         return $this;
  1763.     }
  1765.     public function removeTheClass(TheClass $theClass): static
  1766.     {
  1767.         if ($this->theClasses->removeElement($theClass)) {
  1768.             // set the owning side to null (unless already changed)
  1769.             if ($theClass->getAuthor() === $this) {
  1770.                 $theClass->setAuthor(null);
  1771.             }
  1772.         }
  1774.         return $this;
  1775.     }
  1777.     /**
  1778.      * @return Collection<int, TheClass>
  1779.      */
  1780.     public function getTheClassesEdited(): Collection
  1781.     {
  1782.         return $this->theClassesEdited;
  1783.     }
  1785.     public function addTheClassesEdited(TheClass $theClassesEdited): static
  1786.     {
  1787.         if (!$this->theClassesEdited->contains($theClassesEdited)) {
  1788.             $this->theClassesEdited->add($theClassesEdited);
  1789.             $theClassesEdited->setEditor($this);
  1790.         }
  1792.         return $this;
  1793.     }
  1795.     public function removeTheClassesEdited(TheClass $theClassesEdited): static
  1796.     {
  1797.         if ($this->theClassesEdited->removeElement($theClassesEdited)) {
  1798.             // set the owning side to null (unless already changed)
  1799.             if ($theClassesEdited->getEditor() === $this) {
  1800.                 $theClassesEdited->setEditor(null);
  1801.             }
  1802.         }
  1804.         return $this;
  1805.     }
  1807.     public function getAuthor(): ?self
  1808.     {
  1809.         return $this->author;
  1810.     }
  1812.     public function setAuthor(?self $author): static
  1813.     {
  1814.         $this->author = $author;
  1816.         return $this;
  1817.     }
  1819.     /**
  1820.      * @return Collection<int, self>
  1821.      */
  1822.     public function getUsers(): Collection
  1823.     {
  1824.         return $this->users;
  1825.     }
  1827.     public function addUser(self $user): static
  1828.     {
  1829.         if (!$this->users->contains($user)) {
  1830.             $this->users->add($user);
  1831.             $user->setAuthor($this);
  1832.         }
  1834.         return $this;
  1835.     }
  1837.     public function removeUser(self $user): static
  1838.     {
  1839.         if ($this->users->removeElement($user)) {
  1840.             // set the owning side to null (unless already changed)
  1841.             if ($user->getAuthor() === $this) {
  1842.                 $user->setAuthor(null);
  1843.             }
  1844.         }
  1846.         return $this;
  1847.     }
  1849.     public function getEditor(): ?self
  1850.     {
  1851.         return $this->editor;
  1852.     }
  1854.     public function setEditor(?self $editor): static
  1855.     {
  1856.         $this->editor = $editor;
  1858.         return $this;
  1859.     }
  1861.     /**
  1862.      * @return Collection<int, self>
  1863.      */
  1864.     public function getUsersEdited(): Collection
  1865.     {
  1866.         return $this->usersEdited;
  1867.     }
  1869.     public function addUsersEdited(self $usersEdited): static
  1870.     {
  1871.         if (!$this->usersEdited->contains($usersEdited)) {
  1872.             $this->usersEdited->add($usersEdited);
  1873.             $usersEdited->setEditor($this);
  1874.         }
  1876.         return $this;
  1877.     }
  1879.     public function removeUsersEdited(self $usersEdited): static
  1880.     {
  1881.         if ($this->usersEdited->removeElement($usersEdited)) {
  1882.             // set the owning side to null (unless already changed)
  1883.             if ($usersEdited->getEditor() === $this) {
  1884.                 $usersEdited->setEditor(null);
  1885.             }
  1886.         }
  1888.         return $this;
  1889.     }
  1891.     /**
  1892.      * @return Collection<int, Student>
  1893.      */
  1894.     public function getStudentsCreated(): Collection
  1895.     {
  1896.         return $this->studentsCreated;
  1897.     }
  1899.     public function addStudentsCreated(Student $studentsCreated): static
  1900.     {
  1901.         if (!$this->studentsCreated->contains($studentsCreated)) {
  1902.             $this->studentsCreated->add($studentsCreated);
  1903.             $studentsCreated->setAuthor($this);
  1904.         }
  1906.         return $this;
  1907.     }
  1909.     public function removeStudentsCreated(Student $studentsCreated): static
  1910.     {
  1911.         if ($this->studentsCreated->removeElement($studentsCreated)) {
  1912.             // set the owning side to null (unless already changed)
  1913.             if ($studentsCreated->getAuthor() === $this) {
  1914.                 $studentsCreated->setAuthor(null);
  1915.             }
  1916.         }
  1918.         return $this;
  1919.     }
  1921.     /**
  1922.      * @return Collection<int, Subject>
  1923.      */
  1924.     public function getSubjectsCreated(): Collection
  1925.     {
  1926.         return $this->subjectsCreated;
  1927.     }
  1929.     public function addSubjectsCreated(Subject $subjectsCreated): static
  1930.     {
  1931.         if (!$this->subjectsCreated->contains($subjectsCreated)) {
  1932.             $this->subjectsCreated->add($subjectsCreated);
  1933.             $subjectsCreated->setAuthor($this);
  1934.         }
  1936.         return $this;
  1937.     }
  1939.     public function removeSubjectsCreated(Subject $subjectsCreated): static
  1940.     {
  1941.         if ($this->subjectsCreated->removeElement($subjectsCreated)) {
  1942.             // set the owning side to null (unless already changed)
  1943.             if ($subjectsCreated->getAuthor() === $this) {
  1944.                 $subjectsCreated->setAuthor(null);
  1945.             }
  1946.         }
  1948.         return $this;
  1949.     }
  1951.     /**
  1952.      * @return Collection<int, News>
  1953.      */
  1954.     public function getNewsEdited(): Collection
  1955.     {
  1956.         return $this->newsEdited;
  1957.     }
  1959.     public function addNewsEdited(News $newsEdited): static
  1960.     {
  1961.         if (!$this->newsEdited->contains($newsEdited)) {
  1962.             $this->newsEdited->add($newsEdited);
  1963.             $newsEdited->setEditor($this);
  1964.         }
  1966.         return $this;
  1967.     }
  1969.     public function removeNewsEdited(News $newsEdited): static
  1970.     {
  1971.         if ($this->newsEdited->removeElement($newsEdited)) {
  1972.             // set the owning side to null (unless already changed)
  1973.             if ($newsEdited->getEditor() === $this) {
  1974.                 $newsEdited->setEditor(null);
  1975.             }
  1976.         }
  1978.         return $this;
  1979.     }
  1981.     /**
  1982.      * @return Collection<int, PunishCategory>
  1983.      */
  1984.     public function getPunishCategories(): Collection
  1985.     {
  1986.         return $this->punishCategories;
  1987.     }
  1989.     public function addPunishCategory(PunishCategory $punishCategory): static
  1990.     {
  1991.         if (!$this->punishCategories->contains($punishCategory)) {
  1992.             $this->punishCategories->add($punishCategory);
  1993.             $punishCategory->setAuthor($this);
  1994.         }
  1996.         return $this;
  1997.     }
  1999.     public function removePunishCategory(PunishCategory $punishCategory): static
  2000.     {
  2001.         if ($this->punishCategories->removeElement($punishCategory)) {
  2002.             // set the owning side to null (unless already changed)
  2003.             if ($punishCategory->getAuthor() === $this) {
  2004.                 $punishCategory->setAuthor(null);
  2005.             }
  2006.         }
  2008.         return $this;
  2009.     }
  2011.     public function getLastRequestTs(): ?string
  2012.     {
  2013.         return $this->lastRequestTs;
  2014.     }
  2016.     public function setLastRequestTs(?string $lastRequestTs): static
  2017.     {
  2018.         $this->lastRequestTs = $lastRequestTs;
  2020.         return $this;
  2021.     }
  2023.     public function getSchool(): ?School
  2024.     {
  2025.         return $this->school;
  2026.     }
  2028.     public function setSchool(?School $school): static
  2029.     {
  2030.         $this->school = $school;
  2032.         return $this;
  2033.     }
  2035.     /**
  2036.      * @return Collection<int, DiscussionClassMessage>
  2037.      */
  2038.     public function getDiscussionClassMessages(): Collection
  2039.     {
  2040.         return $this->discussionClassMessages;
  2041.     }
  2043.     public function addDiscussionClassMessage(DiscussionClassMessage $discussionClassMessage): static
  2044.     {
  2045.         if (!$this->discussionClassMessages->contains($discussionClassMessage)) {
  2046.             $this->discussionClassMessages->add($discussionClassMessage);
  2047.             $discussionClassMessage->setAuthor($this);
  2048.         }
  2050.         return $this;
  2051.     }
  2053.     public function removeDiscussionClassMessage(DiscussionClassMessage $discussionClassMessage): static
  2054.     {
  2055.         if ($this->discussionClassMessages->removeElement($discussionClassMessage)) {
  2056.             // set the owning side to null (unless already changed)
  2057.             if ($discussionClassMessage->getAuthor() === $this) {
  2058.                 $discussionClassMessage->setAuthor(null);
  2059.             }
  2060.         }
  2062.         return $this;
  2063.     }
  2065.     /**
  2066.      * @return Collection<int, Agenda>
  2067.      */
  2068.     public function getAgendas(): Collection
  2069.     {
  2070.         return $this->agendas;
  2071.     }
  2073.     public function addAgenda(Agenda $agenda): static
  2074.     {
  2075.         if (!$this->agendas->contains($agenda)) {
  2076.             $this->agendas->add($agenda);
  2077.             $agenda->setAuthor($this);
  2078.         }
  2080.         return $this;
  2081.     }
  2083.     public function removeAgenda(Agenda $agenda): static
  2084.     {
  2085.         if ($this->agendas->removeElement($agenda)) {
  2086.             // set the owning side to null (unless already changed)
  2087.             if ($agenda->getAuthor() === $this) {
  2088.                 $agenda->setAuthor(null);
  2089.             }
  2090.         }
  2092.         return $this;
  2093.     }
  2095.     /**
  2096.      * @return Collection<int, ExamAgenda>
  2097.      */
  2098.     public function getExamAgendas(): Collection
  2099.     {
  2100.         return $this->examAgendas;
  2101.     }
  2103.     public function addExamAgenda(ExamAgenda $examAgenda): static
  2104.     {
  2105.         if (!$this->examAgendas->contains($examAgenda)) {
  2106.             $this->examAgendas->add($examAgenda);
  2107.             $examAgenda->setAuthor($this);
  2108.         }
  2110.         return $this;
  2111.     }
  2113.     public function removeExamAgenda(ExamAgenda $examAgenda): static
  2114.     {
  2115.         if ($this->examAgendas->removeElement($examAgenda)) {
  2116.             // set the owning side to null (unless already changed)
  2117.             if ($examAgenda->getAuthor() === $this) {
  2118.                 $examAgenda->setAuthor(null);
  2119.             }
  2120.         }
  2122.         return $this;
  2123.     }
  2125.     /**
  2126.      * @return Collection<int, SubSequence>
  2127.      */
  2128.     public function getSubSequences(): Collection
  2129.     {
  2130.         return $this->subSequences;
  2131.     }
  2133.     public function addSubSequence(SubSequence $subSequence): static
  2134.     {
  2135.         if (!$this->subSequences->contains($subSequence)) {
  2136.             $this->subSequences->add($subSequence);
  2137.             $subSequence->setAuthor($this);
  2138.         }
  2140.         return $this;
  2141.     }
  2143.     public function removeSubSequence(SubSequence $subSequence): static
  2144.     {
  2145.         if ($this->subSequences->removeElement($subSequence)) {
  2146.             // set the owning side to null (unless already changed)
  2147.             if ($subSequence->getAuthor() === $this) {
  2148.                 $subSequence->setAuthor(null);
  2149.             }
  2150.         }
  2152.         return $this;
  2153.     }
  2155.     /**
  2156.      * @return Collection<int, Quarter>
  2157.      */
  2158.     public function getQuarters(): Collection
  2159.     {
  2160.         return $this->quarters;
  2161.     }
  2163.     public function addQuarter(Quarter $quarter): static
  2164.     {
  2165.         if (!$this->quarters->contains($quarter)) {
  2166.             $this->quarters->add($quarter);
  2167.             $quarter->setAuthor($this);
  2168.         }
  2170.         return $this;
  2171.     }
  2173.     public function removeQuarter(Quarter $quarter): static
  2174.     {
  2175.         if ($this->quarters->removeElement($quarter)) {
  2176.             // set the owning side to null (unless already changed)
  2177.             if ($quarter->getAuthor() === $this) {
  2178.                 $quarter->setAuthor(null);
  2179.             }
  2180.         }
  2182.         return $this;
  2183.     }
  2185.     /**
  2186.      * @return Collection<int, SubNote>
  2187.      */
  2188.     public function getSubNotes(): Collection
  2189.     {
  2190.         return $this->subNotes;
  2191.     }
  2193.     public function addSubNote(SubNote $subNote): static
  2194.     {
  2195.         if (!$this->subNotes->contains($subNote)) {
  2196.             $this->subNotes->add($subNote);
  2197.             $subNote->setAuthor($this);
  2198.         }
  2200.         return $this;
  2201.     }
  2203.     public function removeSubNote(SubNote $subNote): static
  2204.     {
  2205.         if ($this->subNotes->removeElement($subNote)) {
  2206.             // set the owning side to null (unless already changed)
  2207.             if ($subNote->getAuthor() === $this) {
  2208.                 $subNote->setAuthor(null);
  2209.             }
  2210.         }
  2212.         return $this;
  2213.     }
  2215.     /**
  2216.      * @return Collection<int, AgendaDay>
  2217.      */
  2218.     public function getAgendaDays(): Collection
  2219.     {
  2220.         return $this->agendaDays;
  2221.     }
  2223.     public function addAgendaDay(AgendaDay $agendaDay): static
  2224.     {
  2225.         if (!$this->agendaDays->contains($agendaDay)) {
  2226.             $this->agendaDays->add($agendaDay);
  2227.             $agendaDay->setAuthor($this);
  2228.         }
  2230.         return $this;
  2231.     }
  2233.     public function removeAgendaDay(AgendaDay $agendaDay): static
  2234.     {
  2235.         if ($this->agendaDays->removeElement($agendaDay)) {
  2236.             // set the owning side to null (unless already changed)
  2237.             if ($agendaDay->getAuthor() === $this) {
  2238.                 $agendaDay->setAuthor(null);
  2239.             }
  2240.         }
  2242.         return $this;
  2243.     }
  2245.     /**
  2246.      * @return Collection<int, AgendaElement>
  2247.      */
  2248.     public function getAgendaElements(): Collection
  2249.     {
  2250.         return $this->agendaElements;
  2251.     }
  2253.     public function addAgendaElement(AgendaElement $agendaElement): static
  2254.     {
  2255.         if (!$this->agendaElements->contains($agendaElement)) {
  2256.             $this->agendaElements->add($agendaElement);
  2257.             $agendaElement->setAuthor($this);
  2258.         }
  2260.         return $this;
  2261.     }
  2263.     public function removeAgendaElement(AgendaElement $agendaElement): static
  2264.     {
  2265.         if ($this->agendaElements->removeElement($agendaElement)) {
  2266.             // set the owning side to null (unless already changed)
  2267.             if ($agendaElement->getAuthor() === $this) {
  2268.                 $agendaElement->setAuthor(null);
  2269.             }
  2270.         }
  2272.         return $this;
  2273.     }
  2275.     /**
  2276.      * @return Collection<int, ExamAgendaDay>
  2277.      */
  2278.     public function getExamAgendaDays(): Collection
  2279.     {
  2280.         return $this->examAgendaDays;
  2281.     }
  2283.     public function addExamAgendaDay(ExamAgendaDay $examAgendaDay): static
  2284.     {
  2285.         if (!$this->examAgendaDays->contains($examAgendaDay)) {
  2286.             $this->examAgendaDays->add($examAgendaDay);
  2287.             $examAgendaDay->setAuthor($this);
  2288.         }
  2290.         return $this;
  2291.     }
  2293.     public function removeExamAgendaDay(ExamAgendaDay $examAgendaDay): static
  2294.     {
  2295.         if ($this->examAgendaDays->removeElement($examAgendaDay)) {
  2296.             // set the owning side to null (unless already changed)
  2297.             if ($examAgendaDay->getAuthor() === $this) {
  2298.                 $examAgendaDay->setAuthor(null);
  2299.             }
  2300.         }
  2302.         return $this;
  2303.     }
  2305.     /**
  2306.      * @return Collection<int, ExamAgendaElement>
  2307.      */
  2308.     public function getExamAgendaElements(): Collection
  2309.     {
  2310.         return $this->examAgendaElements;
  2311.     }
  2313.     public function addExamAgendaElement(ExamAgendaElement $examAgendaElement): static
  2314.     {
  2315.         if (!$this->examAgendaElements->contains($examAgendaElement)) {
  2316.             $this->examAgendaElements->add($examAgendaElement);
  2317.             $examAgendaElement->setAuthor($this);
  2318.         }
  2320.         return $this;
  2321.     }
  2323.     public function removeExamAgendaElement(ExamAgendaElement $examAgendaElement): static
  2324.     {
  2325.         if ($this->examAgendaElements->removeElement($examAgendaElement)) {
  2326.             // set the owning side to null (unless already changed)
  2327.             if ($examAgendaElement->getAuthor() === $this) {
  2328.                 $examAgendaElement->setAuthor(null);
  2329.             }
  2330.         }
  2332.         return $this;
  2333.     }
  2335.     /**
  2336.      * @return Collection<int, Appreciation>
  2337.      */
  2338.     public function getAppreciations(): Collection
  2339.     {
  2340.         return $this->appreciations;
  2341.     }
  2343.     public function addAppreciation(Appreciation $appreciation): static
  2344.     {
  2345.         if (!$this->appreciations->contains($appreciation)) {
  2346.             $this->appreciations->add($appreciation);
  2347.             $appreciation->setAuthor($this);
  2348.         }
  2349.         return $this;
  2350.     }
  2352.     public function removeAppreciation(Appreciation $appreciation): static
  2353.     {
  2354.         if ($this->appreciations->removeElement($appreciation)) {
  2355.             // set the owning side to null (unless already changed)
  2356.             if ($appreciation->getAuthor() === $this) {
  2357.                 $appreciation->setAuthor(null);
  2358.             }
  2359.         }
  2360.         return $this;
  2361.     }
  2362.     
  2363.     /**
  2364.      * @return Collection<int, LocalAccount>
  2365.      */
  2366.     public function getLocalAccounts(): Collection
  2367.     {
  2368.         return $this->localAccounts;
  2369.     }
  2371.     public function addLocalAccount(LocalAccount $localAccount): static
  2372.     {
  2373.         if (!$this->localAccounts->contains($localAccount)) {
  2374.             $this->localAccounts->add($localAccount);
  2375.             $localAccount->setUser($this);
  2376.         }
  2378.         return $this;
  2379.     }
  2381.     public function removeLocalAccount(LocalAccount $localAccount): static
  2382.     {
  2383.         if ($this->localAccounts->removeElement($localAccount)) {
  2384.             // set the owning side to null (unless already changed)
  2385.             if ($localAccount->getUser() === $this) {
  2386.                 $localAccount->setUser(null);
  2387.             }
  2388.         }
  2390.         return $this;
  2391.     }
  2393.     /**
  2394.      * @return Collection<int, NewsBookmark>
  2395.      */
  2396.     public function getNewsBookmarks(): Collection
  2397.     {
  2398.         return $this->newsBookmarks;
  2399.     }
  2401.     public function addNewsBookmark(NewsBookmark $newsBookmark): static
  2402.     {
  2403.         if (!$this->newsBookmarks->contains($newsBookmark)) {
  2404.             $this->newsBookmarks->add($newsBookmark);
  2405.             $newsBookmark->setUser($this);
  2406.         }
  2407.         return $this;
  2408.     }
  2410.     /**
  2411.      * @return Collection<int, ScolarityHistory>
  2412.      */
  2413.     public function getScolarityHistories(): Collection
  2414.     {
  2415.         return $this->scolarityHistories;
  2416.     }
  2418.     public function addScolarityHistory(ScolarityHistory $scolarityHistory): static
  2419.     {
  2420.         if (!$this->scolarityHistories->contains($scolarityHistory)) {
  2421.             $this->scolarityHistories->add($scolarityHistory);
  2422.             $scolarityHistory->setAuthor($this);
  2423.         }
  2425.         return $this;
  2426.     }
  2429.     public function removeNewsBookmark(NewsBookmark $newsBookmark): static
  2430.     {
  2431.         if ($this->newsBookmarks->removeElement($newsBookmark)) {
  2432.             // set the owning side to null (unless already changed)
  2433.             if ($newsBookmark->getUser() === $this) {
  2434.                 $newsBookmark->setUser(null);
  2435.             }
  2436.             return $this;
  2437.         }
  2438.     }
  2440.     public function removeScolarityHistory(ScolarityHistory $scolarityHistory): static
  2441.     {
  2442.         if ($this->scolarityHistories->removeElement($scolarityHistory)) {
  2443.             // set the owning side to null (unless already changed)
  2444.             if ($scolarityHistory->getAuthor() === $this) {
  2445.                 $scolarityHistory->setAuthor(null);
  2446.             }
  2447.         }
  2449.         return $this;
  2450.     }
  2452.     /**
  2453.      * @return Collection<int, HomeworkBookmark>
  2454.      */
  2455.     public function getHomeworkBookmarks(): Collection
  2456.     {
  2457.         return $this->homeworkBookmarks;
  2458.     }
  2460.     public function addHomeworkBookmark(HomeworkBookmark $homeworkBookmark): static
  2461.     {
  2462.         if (!$this->homeworkBookmarks->contains($homeworkBookmark)) {
  2463.             $this->homeworkBookmarks->add($homeworkBookmark);
  2464.             $homeworkBookmark->setUser($this);
  2465.         }
  2466.         return $this;
  2467.     }
  2469.     /**
  2470.      * @return Collection<int, ScolarityHistoryEdition>
  2471.      */
  2472.     public function getScolarityHistoryEditions(): Collection
  2473.     {
  2474.         return $this->scolarityHistoryEditions;
  2475.     }
  2477.     public function addScolarityHistoryEditon(ScolarityHistoryEdition $scolarityHistoryEdition): static
  2478.     {
  2479.         if (!$this->scolarityHistoryEditions->contains($scolarityHistoryEdition)) {
  2480.             $this->scolarityHistoryEditions->add($scolarityHistoryEdition);
  2481.             $scolarityHistoryEdition->setAuthor($this);
  2482.         }
  2484.         return $this;
  2485.     }
  2488.     public function removeHomeworkBookmark(HomeworkBookmark $homeworkBookmark): static
  2489.     {
  2490.         if ($this->homeworkBookmarks->removeElement($homeworkBookmark)) {
  2491.             // set the owning side to null (unless already changed)
  2492.             if ($homeworkBookmark->getUser() === $this) {
  2493.                 $homeworkBookmark->setUser(null);
  2494.             }
  2495.             return $this;
  2496.         }
  2497.     }
  2498.     public function removeScolarityHistoryEdition(ScolarityHistoryEdition $scolarityHistoryEdition): static
  2499.     {
  2500.         if ($this->scolarityHistoryEditions->removeElement($scolarityHistoryEdition)) {
  2501.             // set the owning side to null (unless already changed)
  2502.             if ($scolarityHistoryEdition->getAuthor() === $this) {
  2503.                 $scolarityHistoryEdition->setAuthor(null);
  2504.             }
  2505.         }
  2507.         return $this;
  2508.     }
  2510.     /**
  2511.      * @return Collection<int, JustifyAbsence>
  2512.      */
  2513.     public function getJustifyAbsences(): Collection
  2514.     {
  2515.         return $this->justifyAbsences;
  2516.     }
  2518.     public function addJustifyAbsence(JustifyAbsence $justifyAbsence): static
  2519.     {
  2520.         if (!$this->justifyAbsences->contains($justifyAbsence)) {
  2521.             $this->justifyAbsences->add($justifyAbsence);
  2522.             $justifyAbsence->setAuthor($this);
  2523.         }
  2525.         return $this;
  2526.     }
  2528.     public function removeJustifyAbsence(JustifyAbsence $justifyAbsence): static
  2529.     {
  2530.         if ($this->justifyAbsences->removeElement($justifyAbsence)) {
  2531.             // set the owning side to null (unless already changed)
  2532.             if ($justifyAbsence->getAuthor() === $this) {
  2533.                 $justifyAbsence->setAuthor(null);
  2534.             }
  2535.         }
  2537.         return $this;
  2538.     }
  2540.     /**
  2541.      * @return Collection<int, VerbalProcess>
  2542.      */
  2543.     public function getVerbalProcesses(): Collection
  2544.     {
  2545.         return $this->verbalProcesses;
  2546.     }
  2548.     public function addVerbalProcess(VerbalProcess $verbalProcess): static
  2549.     {
  2550.         if (!$this->verbalProcesses->contains($verbalProcess)) {
  2551.             $this->verbalProcesses->add($verbalProcess);
  2552.             $verbalProcess->setAuthor($this);
  2553.         }
  2555.         return $this;
  2556.     }
  2558.     public function removeVerbalProcess(VerbalProcess $verbalProcess): static
  2559.     {
  2560.         if ($this->verbalProcesses->removeElement($verbalProcess)) {
  2561.             // set the owning side to null (unless already changed)
  2562.             if ($verbalProcess->getAuthor() === $this) {
  2563.                 $verbalProcess->setAuthor(null);
  2564.             }
  2565.         }
  2567.         return $this;
  2568.     }
  2570.     /**
  2571.      * @return Collection<int, AbsenceDisciplineConcileConfig>
  2572.      */
  2573.     public function getAbsenceDisciplineConcileConfigs(): Collection
  2574.     {
  2575.         return $this->absenceDisciplineConcileConfigs;
  2576.     }
  2578.     public function addAbsenceDisciplineConcileConfig(AbsenceDisciplineConcileConfig $absenceDisciplineConcileConfig): static
  2579.     {
  2580.         if (!$this->absenceDisciplineConcileConfigs->contains($absenceDisciplineConcileConfig)) {
  2581.             $this->absenceDisciplineConcileConfigs->add($absenceDisciplineConcileConfig);
  2582.             $absenceDisciplineConcileConfig->setAuthor($this);
  2583.         }
  2585.         return $this;
  2586.     }
  2588.     public function removeAbsenceDisciplineConcileConfig(AbsenceDisciplineConcileConfig $absenceDisciplineConcileConfig): static
  2589.     {
  2590.         if ($this->absenceDisciplineConcileConfigs->removeElement($absenceDisciplineConcileConfig)) {
  2591.             // set the owning side to null (unless already changed)
  2592.             if ($absenceDisciplineConcileConfig->getAuthor() === $this) {
  2593.                 $absenceDisciplineConcileConfig->setAuthor(null);
  2594.             }
  2595.         }
  2597.         return $this;
  2598.     }
  2600.     /**
  2601.      * @return Collection<int, TheClass>
  2602.      */
  2603.     public function getTheClassesTeached(): Collection
  2604.     {
  2605.         return $this->theClassesTeached;
  2606.     }
  2608.     public function addTheClassesTeached(TheClass $theClassesTeached): static
  2609.     {
  2610.         if (!$this->theClassesTeached->contains($theClassesTeached)) {
  2611.             $this->theClassesTeached->add($theClassesTeached);
  2612.             $theClassesTeached->setProf($this);
  2613.         }
  2615.         return $this;
  2616.     }
  2618.     public function removeTheClassesTeached(TheClass $theClassesTeached): static
  2619.     {
  2620.         if ($this->theClassesTeached->removeElement($theClassesTeached)) {
  2621.             // set the owning side to null (unless already changed)
  2622.             if ($theClassesTeached->getProf() === $this) {
  2623.                 $theClassesTeached->setProf(null);
  2624.             }
  2625.         }
  2627.         return $this;
  2628.     }
  2630.     /**
  2631.      * @return Collection<int, PrimaryNote>
  2632.      */
  2633.     public function getPrimaryNotes(): Collection
  2634.     {
  2635.         return $this->primaryNotes;
  2636.     }
  2638.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  2639.     {
  2640.         if (!$this->primaryNotes->contains($primaryNote)) {
  2641.             $this->primaryNotes->add($primaryNote);
  2642.             $primaryNote->setAuthor($this);
  2643.         }
  2645.         return $this;
  2646.     }
  2648.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  2649.     {
  2650.         if ($this->primaryNotes->removeElement($primaryNote)) {
  2651.             // set the owning side to null (unless already changed)
  2652.             if ($primaryNote->getAuthor() === $this) {
  2653.                 $primaryNote->setAuthor(null);
  2654.             }
  2655.         }
  2657.         return $this;
  2658.     }
  2660.     /**
  2661.      * @return Collection<int, VerbalProcessCategory>
  2662.      */
  2663.     public function getVerbalProcessCategories(): Collection
  2664.     {
  2665.         return $this->verbalProcessCategories;
  2666.     }
  2668.     public function addVerbalProcessCategory(VerbalProcessCategory $verbalProcessCategory): static
  2669.     {
  2670.         if (!$this->verbalProcessCategories->contains($verbalProcessCategory)) {
  2671.             $this->verbalProcessCategories->add($verbalProcessCategory);
  2672.             $verbalProcessCategory->setAuthor($this);
  2673.         }
  2675.         return $this;
  2676.     }
  2678.     public function removeVerbalProcessCategory(VerbalProcessCategory $verbalProcessCategory): static
  2679.     {
  2680.         if ($this->verbalProcessCategories->removeElement($verbalProcessCategory)) {
  2681.             // set the owning side to null (unless already changed)
  2682.             if ($verbalProcessCategory->getAuthor() === $this) {
  2683.                 $verbalProcessCategory->setAuthor(null);
  2684.             }
  2685.         }
  2687.         return $this;
  2688.     }
  2690.     public function getTheme(): ?string
  2691.     {
  2692.         return $this->theme;
  2693.     }
  2695.     public function setTheme(?string $theme): static
  2696.     {
  2697.         $this->theme = $theme;
  2699.         return $this;
  2700.     }
  2702.     public function getPicture(): ?string
  2703.     {
  2704.         return $this->picture;
  2705.     }
  2707.     public function setPicture(?string $picture): static
  2708.     {
  2709.         $this->picture = $picture;
  2711.         return $this;
  2712.     }
  2714.     public function getSexe(): ?string
  2715.     {
  2716.         return $this->sexe;
  2717.     }
  2719.     public function setSexe(?string $sexe): static
  2720.     {
  2721.         $this->sexe = $sexe;
  2723.         return $this;
  2724.     }
  2726.     /**
  2727.      * @return Collection<int, UserAndroidToken>
  2728.      */
  2729.     public function getUserAndroidTokens(): Collection
  2730.     {
  2731.         return $this->userAndroidTokens;
  2732.     }
  2734.     public function addUserAndroidToken(UserAndroidToken $userAndroidToken): static
  2735.     {
  2736.         if (!$this->userAndroidTokens->contains($userAndroidToken)) {
  2737.             $this->userAndroidTokens->add($userAndroidToken);
  2738.             $userAndroidToken->setUser($this);
  2739.         }
  2741.         return $this;
  2742.     }
  2744.     public function removeUserAndroidToken(UserAndroidToken $userAndroidToken): static
  2745.     {
  2746.         if ($this->userAndroidTokens->removeElement($userAndroidToken)) {
  2747.             // set the owning side to null (unless already changed)
  2748.             if ($userAndroidToken->getUser() === $this) {
  2749.                 $userAndroidToken->setUser(null);
  2750.             }
  2751.         }
  2753.         return $this;
  2754.     }
  2756.     /**
  2757.      * @return Collection<int, UserIphoneToken>
  2758.      */
  2759.     public function getUserIphoneTokens(): Collection
  2760.     {
  2761.         return $this->userIphoneTokens;
  2762.     }
  2764.     public function addUserIphoneToken(UserIphoneToken $userIphoneToken): static
  2765.     {
  2766.         if (!$this->userIphoneTokens->contains($userIphoneToken)) {
  2767.             $this->userIphoneTokens->add($userIphoneToken);
  2768.             $userIphoneToken->setUser($this);
  2769.         }
  2771.         return $this;
  2772.     }
  2774.     public function removeUserIphoneToken(UserIphoneToken $userIphoneToken): static
  2775.     {
  2776.         if ($this->userIphoneTokens->removeElement($userIphoneToken)) {
  2777.             // set the owning side to null (unless already changed)
  2778.             if ($userIphoneToken->getUser() === $this) {
  2779.                 $userIphoneToken->setUser(null);
  2780.             }
  2781.         }
  2783.         return $this;
  2784.     }
  2786.     public function getLocalPhoneLang(): ?string
  2787.     {
  2788.         return $this->localPhoneLang;
  2789.     }
  2791.     public function setLocalPhoneLang(?string $localPhoneLang): static
  2792.     {
  2793.         $this->localPhoneLang = $localPhoneLang;
  2795.         return $this;
  2796.     }
  2798.     /**
  2799.      * @return Collection<int, AbsenceBlameConfig>
  2800.      */
  2801.     public function getAbsenceBlameConfigs(): Collection
  2802.     {
  2803.         return $this->absenceBlameConfigs;
  2804.     }
  2806.     public function addAbsenceBlameConfig(AbsenceBlameConfig $absenceBlameConfig): static
  2807.     {
  2808.         if (!$this->absenceBlameConfigs->contains($absenceBlameConfig)) {
  2809.             $this->absenceBlameConfigs->add($absenceBlameConfig);
  2810.             $absenceBlameConfig->setAuthor($this);
  2811.         }
  2813.         return $this;
  2814.     }
  2816.     public function removeAbsenceBlameConfig(AbsenceBlameConfig $absenceBlameConfig): static
  2817.     {
  2818.         if ($this->absenceBlameConfigs->removeElement($absenceBlameConfig)) {
  2819.             // set the owning side to null (unless already changed)
  2820.             if ($absenceBlameConfig->getAuthor() === $this) {
  2821.                 $absenceBlameConfig->setAuthor(null);
  2822.             }
  2823.         }
  2825.         return $this;
  2826.     }
  2828.     /**
  2829.      * @return Collection<int, AbsenceWarningConfig>
  2830.      */
  2831.     public function getAbsenceWarningConfigs(): Collection
  2832.     {
  2833.         return $this->absenceWarningConfigs;
  2834.     }
  2836.     public function addAbsenceWarningConfig(AbsenceWarningConfig $absenceWarningConfig): static
  2837.     {
  2838.         if (!$this->absenceWarningConfigs->contains($absenceWarningConfig)) {
  2839.             $this->absenceWarningConfigs->add($absenceWarningConfig);
  2840.             $absenceWarningConfig->setAuthor($this);
  2841.         }
  2843.         return $this;
  2844.     }
  2846.     public function removeAbsenceWarningConfig(AbsenceWarningConfig $absenceWarningConfig): static
  2847.     {
  2848.         if ($this->absenceWarningConfigs->removeElement($absenceWarningConfig)) {
  2849.             // set the owning side to null (unless already changed)
  2850.             if ($absenceWarningConfig->getAuthor() === $this) {
  2851.                 $absenceWarningConfig->setAuthor(null);
  2852.             }
  2853.         }
  2855.         return $this;
  2856.     }
  2858.     /**
  2859.      * @return Collection<int, AbsencePunishConfig>
  2860.      */
  2861.     public function getAbsencePunishConfigs(): Collection
  2862.     {
  2863.         return $this->absencePunishConfigs;
  2864.     }
  2866.     public function addAbsencePunishConfig(AbsencePunishConfig $absencePunishConfig): static
  2867.     {
  2868.         if (!$this->absencePunishConfigs->contains($absencePunishConfig)) {
  2869.             $this->absencePunishConfigs->add($absencePunishConfig);
  2870.             $absencePunishConfig->setAuthor($this);
  2871.         }
  2873.         return $this;
  2874.     }
  2876.     public function removeAbsencePunishConfig(AbsencePunishConfig $absencePunishConfig): static
  2877.     {
  2878.         if ($this->absencePunishConfigs->removeElement($absencePunishConfig)) {
  2879.             // set the owning side to null (unless already changed)
  2880.             if ($absencePunishConfig->getAuthor() === $this) {
  2881.                 $absencePunishConfig->setAuthor(null);
  2882.             }
  2883.         }
  2885.         return $this;
  2886.     }
  2888.     /**
  2889.      * @return Collection<int, AbsenceExclusionConfig>
  2890.      */
  2891.     public function getAbsenceExclusionConfigs(): Collection
  2892.     {
  2893.         return $this->absenceExclusionConfigs;
  2894.     }
  2896.     public function addAbsenceExclusionConfig(AbsenceExclusionConfig $absenceExclusionConfig): static
  2897.     {
  2898.         if (!$this->absenceExclusionConfigs->contains($absenceExclusionConfig)) {
  2899.             $this->absenceExclusionConfigs->add($absenceExclusionConfig);
  2900.             $absenceExclusionConfig->setAuthor($this);
  2901.         }
  2903.         return $this;
  2904.     }
  2906.     public function removeAbsenceExclusionConfig(AbsenceExclusionConfig $absenceExclusionConfig): static
  2907.     {
  2908.         if ($this->absenceExclusionConfigs->removeElement($absenceExclusionConfig)) {
  2909.             // set the owning side to null (unless already changed)
  2910.             if ($absenceExclusionConfig->getAuthor() === $this) {
  2911.                 $absenceExclusionConfig->setAuthor(null);
  2912.             }
  2913.         }
  2915.         return $this;
  2916.     }
  2918.     /**
  2919.      * @return Collection<int, GlobalDisciplineEnabledConfig>
  2920.      */
  2921.     public function getGlobalDisciplineEnabledConfigs(): Collection
  2922.     {
  2923.         return $this->globalDisciplineEnabledConfigs;
  2924.     }
  2926.     public function addGlobalDisciplineEnabledConfig(GlobalDisciplineEnabledConfig $globalDisciplineEnabledConfig): static
  2927.     {
  2928.         if (!$this->globalDisciplineEnabledConfigs->contains($globalDisciplineEnabledConfig)) {
  2929.             $this->globalDisciplineEnabledConfigs->add($globalDisciplineEnabledConfig);
  2930.             $globalDisciplineEnabledConfig->setAuthor($this);
  2931.         }
  2933.         return $this;
  2934.     }
  2936.     public function removeGlobalDisciplineEnabledConfig(GlobalDisciplineEnabledConfig $globalDisciplineEnabledConfig): static
  2937.     {
  2938.         if ($this->globalDisciplineEnabledConfigs->removeElement($globalDisciplineEnabledConfig)) {
  2939.             // set the owning side to null (unless already changed)
  2940.             if ($globalDisciplineEnabledConfig->getAuthor() === $this) {
  2941.                 $globalDisciplineEnabledConfig->setAuthor(null);
  2942.             }
  2943.         }
  2945.         return $this;
  2946.     }
  2948.     /**
  2949.      * @return Collection<int, AbsenceRetainedConfig>
  2950.      */
  2951.     public function getAbsenceRetainedConfigs(): Collection
  2952.     {
  2953.         return $this->absenceRetainedConfigs;
  2954.     }
  2956.     public function addAbsenceRetainedConfig(AbsenceRetainedConfig $absenceRetainedConfig): static
  2957.     {
  2958.         if (!$this->absenceRetainedConfigs->contains($absenceRetainedConfig)) {
  2959.             $this->absenceRetainedConfigs->add($absenceRetainedConfig);
  2960.             $absenceRetainedConfig->setAuthor($this);
  2961.         }
  2963.         return $this;
  2964.     }
  2966.     public function removeAbsenceRetainedConfig(AbsenceRetainedConfig $absenceRetainedConfig): static
  2967.     {
  2968.         if ($this->absenceRetainedConfigs->removeElement($absenceRetainedConfig)) {
  2969.             // set the owning side to null (unless already changed)
  2970.             if ($absenceRetainedConfig->getAuthor() === $this) {
  2971.                 $absenceRetainedConfig->setAuthor(null);
  2972.             }
  2973.         }
  2975.         return $this;
  2976.     }
  2978.     public function getUserToken(): ?string
  2979.     {
  2980.         return $this->userToken;
  2981.     }
  2983.     public function setUserToken(?string $userToken): static
  2984.     {
  2985.         $this->userToken = $userToken;
  2987.         return $this;
  2988.     }
  2990.     /**
  2991.      * @return Collection<int, DisciplineConcile>
  2992.      */
  2993.     public function getDisciplineConciles(): Collection
  2994.     {
  2995.         return $this->disciplineConciles;
  2996.     }
  2998.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  2999.     {
  3000.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  3001.             $this->disciplineConciles->add($disciplineConcile);
  3002.             $disciplineConcile->setAuthor($this);
  3003.         }
  3005.         return $this;
  3006.     }
  3008.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  3009.     {
  3010.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  3011.             // set the owning side to null (unless already changed)
  3012.             if ($disciplineConcile->getAuthor() === $this) {
  3013.                 $disciplineConcile->setAuthor(null);
  3014.             }
  3015.         }
  3017.         return $this;
  3018.     }
  3020.     /**
  3021.      * @return Collection<int, UserNotifications>
  3022.      */
  3023.     public function getUserNotifications(): Collection
  3024.     {
  3025.         return $this->userNotifications;
  3026.     }
  3028.     public function addUserNotification(UserNotifications $userNotification): static
  3029.     {
  3030.         if (!$this->userNotifications->contains($userNotification)) {
  3031.             $this->userNotifications->add($userNotification);
  3032.             $userNotification->setUser($this);
  3033.         }
  3035.         return $this;
  3036.     }
  3038.     public function removeUserNotification(UserNotifications $userNotification): static
  3039.     {
  3040.         if ($this->userNotifications->removeElement($userNotification)) {
  3041.             // set the owning side to null (unless already changed)
  3042.             if ($userNotification->getUser() === $this) {
  3043.                 $userNotification->setUser(null);
  3044.             }
  3045.         }
  3047.         return $this;
  3048.     }
  3050.     /**
  3051.      * @return Collection<int, TimeTable>
  3052.      */
  3053.     public function getTimeTables(): Collection
  3054.     {
  3055.         return $this->timeTables;
  3056.     }
  3058.     public function addTimeTable(TimeTable $timeTable): static
  3059.     {
  3060.         if (!$this->timeTables->contains($timeTable)) {
  3061.             $this->timeTables->add($timeTable);
  3062.             $timeTable->setProf($this);
  3063.         }
  3065.         return $this;
  3066.     }
  3068.     public function removeTimeTable(TimeTable $timeTable): static
  3069.     {
  3070.         if ($this->timeTables->removeElement($timeTable)) {
  3071.             // set the owning side to null (unless already changed)
  3072.             if ($timeTable->getProf() === $this) {
  3073.                 $timeTable->setProf(null);
  3074.             }
  3075.         }
  3077.         return $this;
  3078.     }
  3080.     /**
  3081.      * @return Collection<int, DiscussionMessagesCount>
  3082.      */
  3083.     public function getDiscussionMessagesCounts(): Collection
  3084.     {
  3085.         return $this->discussionMessagesCounts;
  3086.     }
  3088.     public function addDiscussionMessagesCount(DiscussionMessagesCount $discussionMessagesCount): static
  3089.     {
  3090.         if (!$this->discussionMessagesCounts->contains($discussionMessagesCount)) {
  3091.             $this->discussionMessagesCounts->add($discussionMessagesCount);
  3092.             $discussionMessagesCount->setUser($this);
  3093.         }
  3095.         return $this;
  3096.     }
  3098.     public function removeDiscussionMessagesCount(DiscussionMessagesCount $discussionMessagesCount): static
  3099.     {
  3100.         if ($this->discussionMessagesCounts->removeElement($discussionMessagesCount)) {
  3101.             // set the owning side to null (unless already changed)
  3102.             if ($discussionMessagesCount->getUser() === $this) {
  3103.                 $discussionMessagesCount->setUser(null);
  3104.             }
  3105.         }
  3107.         return $this;
  3108.     }
  3109. }