src/Entity/User.php line 23

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. // Accélère la recherche d'un parent existant par téléphone pendant l'import Excel des élèves
  20. // (sinon, scan complet de la table user - partagée par TOUS les comptes de TOUTES les écoles).
  21. #[ORM\Index(name: 'idx_user_phone_type', columns: ['phone', 'user_type'])]
  22. #[UniqueEntity(fields: ['phone'], message: 'There is already an account with this email')]
  23. class User implements UserInterface, PasswordAuthenticatedUserInterface
  24. {
  25.     use Timestampable;
  26.     #[ORM\Id]
  27.     #[ORM\GeneratedValue]
  28.     #[ORM\Column]
  29.     #[Groups(['chatWebNew', 'chatView', 'chatAllList', 'singleMessage','getDiscussion','getStudents','getSubject','getAppUsers', 'getDiscussionMessage','getDiscussionClassMessage','getAbsence','getLate','homework','getPunish'])]
  30.     private ?int $id = null;
  32.     #[ORM\Column(length: 180, nullable: true)]
  35.     #[Groups(["getAppUsers"])]
  36.     private ?string $email = null;
  38.     #[ORM\Column]
  39.     private array $roles = [];
  41.     /**
  42.      * @var string The hashed password
  43.      */
  44.     #[ORM\Column]
  45.     private ?string $password = null;
  47.     #[ORM\Column(length: 255, nullable: true)]
  48.     #[Groups(['chatWebNew', 'chatAllList','getDiscussion','getAppUsers', 'getDiscussionMessage','getDiscussionClassMessage'])]
  49.     private ?string $firstName = null;
  51.     #[ORM\Column(length: 255, nullable: true)]
  52.     #[Groups(['chatWebNew', 'chatAllList','getDiscussion','getAppUsers', 'getDiscussionMessage', 'getDiscussionClassMessage'])]
  53.     private ?string $lastName = null;
  55.     #[ORM\Column(length: 255)]
  56.     #[Groups(['getAppUsers'])]
  57.     private ?string $phone = null;
  59.     #[ORM\Column(length: 255)]
  60.     #[Groups(['chatWebNew','getDiscussion','getAppUsers', 'getDiscussionMessage', 'getDiscussionClassMessage'])]
  61.     private ?string $userType = null;
  63.     #[ORM\Column(type: 'boolean')]
  64.     private $isVerified = false;
  66.     // Compte fermé par un admin (élève ou parent) — bloque login ET
  67.     // requêtes déjà authentifiées (voir App\Security\ActiveUserChecker).
  68.     #[ORM\Column(type: 'boolean')]
  69.     private bool $active = true;
  71.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: News::class)]
  72.     private Collection $news;
  74.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Event::class)]
  75.     private Collection $events;
  77.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserYear::class)]
  78.     private Collection $userYears;
  80.     #[ORM\Column(length: 255, nullable: true)]
  81.     #[Groups(['getAppUsers'])]
  82.     private ?string $matricule = null;
  84.     #[ORM\OneToMany(mappedBy: 'prof', targetEntity: Subject::class)]
  85.     private Collection $subjects;
  87.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: Student::class)]
  88.     private Collection $students;
  90.     // Fiche élève liée quand userType='student' — inverse de Student::$account.
  91.     #[ORM\OneToOne(mappedBy: 'account', targetEntity: Student::class)]
  92.     private ?Student $studentProfile = null;
  94.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: HomeWork::class)]
  95.     private Collection $homeWorks;
  97.     #[ORM\OneToMany(mappedBy: 'initiator', targetEntity: Chat::class)]
  98.     private Collection $chats;
  100.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Message::class)]
  101.     private Collection $messages;
  103.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: DocInfo::class)]
  104.     private Collection $docInfos;
  106.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: DocInfo::class)]
  107.     private Collection $docInfoUpdated;
  109.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: DocInfo::class)]
  110.     private Collection $parentDocInfos;
  112.     #[ORM\OneToMany(mappedBy: 'userA', targetEntity: Discussion::class)]
  113.     private Collection $discussions;
  115.     #[ORM\OneToMany(mappedBy: 'messageBy', targetEntity: DiscussionMessage::class)]
  116.     private Collection $discussionMessages;
  118.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Notifications::class)]
  119.     private Collection $notifications;
  121.     #[ORM\Column(length: 255, nullable: true)]
  122.     private ?string $fullName = null;
  124.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Absence::class)]
  125.     private Collection $absences;
  127.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Absence::class)]
  128.     private Collection $absencesEdited;
  130.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: CategoryEvent::class)]
  131.     private Collection $categoryEvents;
  133.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: CategoryEvent::class)]
  134.     private Collection $categoryEventsEdited;
  136.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ClassYear::class)]
  137.     private Collection $classYears;
  139.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: ClassYear::class)]
  140.     private Collection $ClassYearsEdited;
  142.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Event::class)]
  143.     private Collection $eventsEdited;
  145.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Exams::class)]
  146.     private Collection $exams;
  148.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Exams::class)]
  149.     private Collection $examsEdited;
  151.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: HomeWork::class)]
  152.     private Collection $homeworksEdited;
  154.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Late::class)]
  155.     private Collection $lates;
  157.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Late::class)]
  158.     private Collection $latesEdited;
  160.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: NewsCategory::class)]
  161.     private Collection $newsCategories;
  163.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: NewsCategory::class)]
  164.     private Collection $newsCategoriesEdited;
  166.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Note::class)]
  167.     private Collection $notes;
  169.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Note::class)]
  170.     private Collection $notesEdited;
  172.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: SchoolSection::class)]
  173.     private Collection $schoolSections;
  175.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: SchoolSection::class)]
  176.     private Collection $schoolSectionsEdited;
  178.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: SchoolYear::class)]
  179.     private Collection $schoolYears;
  181.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: SchoolYear::class)]
  182.     private Collection $schoolYearsEdited;
  184.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Student::class)]
  185.     private Collection $studentsEdited;
  187.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: Subject::class)]
  188.     private Collection $subjectsEdited;
  190.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: SubjectGroup::class)]
  191.     private Collection $subjectGroups;
  193.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: SubjectGroup::class)]
  194.     private Collection $subjectGroupsEdited;
  196.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: TheClass::class)]
  197.     private Collection $theClasses;
  199.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: TheClass::class)]
  200.     private Collection $theClassesEdited;
  202.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'users', cascade: ["persist"])]
  203.     private ?self $author = null;
  205.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: self::class)]
  206.     private Collection $users;
  208.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'usersEdited', cascade: ["persist"])]
  209.     private ?self $editor = null;
  211.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: self::class)]
  212.     private Collection $usersEdited;
  214.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Student::class)]
  215.     private Collection $studentsCreated;
  217.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Subject::class)]
  218.     private Collection $subjectsCreated;
  220.     #[ORM\OneToMany(mappedBy: 'editor', targetEntity: News::class)]
  221.     private Collection $newsEdited;
  222.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Punish::class)]
  223.     private Collection $punishes;
  225.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: PunishCategory::class)]
  226.     private Collection $punishCategories;
  228.     #[Groups(['getDiscussion'])]
  229.     #[ORM\Column(type: Types::BIGINT, nullable: true)]
  230.     private ?string $lastRequestTs = null;
  232.     #[ORM\ManyToOne(inversedBy: 'users', cascade: ["persist"])]
  233.     private ?School $school = null;
  235.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: DiscussionClassMessage::class)]
  236.     private Collection $discussionClassMessages;
  238.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Agenda::class)]
  239.     private Collection $agendas;
  241.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ExamAgenda::class)]
  242.     private Collection $examAgendas;
  244.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: SubSequence::class)]
  245.     private Collection $subSequences;
  247.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Quarter::class)]
  248.     private Collection $quarters;
  250.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: SubNote::class)]
  251.     private Collection $subNotes;
  253.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AgendaDay::class)]
  254.     private Collection $agendaDays;
  256.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AgendaElement::class)]
  257.     private Collection $agendaElements;
  259.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ExamAgendaDay::class)]
  260.     private Collection $examAgendaDays;
  262.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ExamAgendaElement::class)]
  263.     private Collection $examAgendaElements;
  265.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Appreciation::class)]
  266.     private Collection $appreciations;
  267.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: LocalAccount::class)]
  268.     private Collection $localAccounts;
  271.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: NewsBookmark::class)]
  272.     private Collection $newsBookmarks;
  274.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: HomeworkBookmark::class)]
  275.     private Collection $homeworkBookmarks;
  277.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ScolarityHistory::class)]
  278.     private Collection $scolarityHistories;
  280.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ScolarityHistoryEdition::class)]
  281.     private Collection $scolarityHistoryEditions;
  283.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: JustifyAbsence::class)]
  284.     private Collection $justifyAbsences;
  286.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: VerbalProcess::class)]
  287.     private Collection $verbalProcesses;
  289.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceDisciplineConcileConfig::class)]
  290.     private Collection $absenceDisciplineConcileConfigs;
  292.     #[ORM\OneToMany(mappedBy: 'prof', targetEntity: TheClass::class)]
  293.     private Collection $theClassesTeached;
  295.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: PrimaryNote::class)]
  296.     private Collection $primaryNotes;
  298.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: VerbalProcessCategory::class)]
  299.     private Collection $verbalProcessCategories;
  301.     #[ORM\Column(length: 255, nullable: true)]
  302.     private ?string $theme = null;
  304.     #[ORM\Column(length: 255, nullable: true)]
  305.     private ?string $picture = null;
  307.     #[ORM\Column(length: 255, nullable: true)]
  308.     private ?string $sexe = null;
  310.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserAndroidToken::class)]
  311.     private Collection $userAndroidTokens;
  313.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserIphoneToken::class)]
  314.     private Collection $userIphoneTokens;
  316.     #[ORM\Column(length: 255, nullable: true)]
  317.     private ?string $localPhoneLang = null;
  319.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceBlameConfig::class)]
  320.     private Collection $absenceBlameConfigs;
  322.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceWarningConfig::class)]
  323.     private Collection $absenceWarningConfigs;
  325.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsencePunishConfig::class)]
  326.     private Collection $absencePunishConfigs;
  328.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceExclusionConfig::class)]
  329.     private Collection $absenceExclusionConfigs;
  331.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: GlobalDisciplineEnabledConfig::class)]
  332.     private Collection $globalDisciplineEnabledConfigs;
  334.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceRetainedConfig::class)]
  335.     private Collection $absenceRetainedConfigs;
  337.     #[ORM\Column(length: 255, nullable: true)]
  338.     private ?string $userToken = null;
  340.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: DisciplineConcile::class)]
  341.     private Collection $disciplineConciles;
  343.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: RefreshToken::class, orphanRemoval: true)]
  344.     private Collection $refreshTokens;
  346.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserNotification::class)]
  347.     private Collection $userNotifications;
  349.     #[ORM\ManyToMany(targetEntity: DiscussionClassMessage::class, mappedBy: 'readers')]
  350.     private Collection $discussionClassMessagesRead;
  352.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: AgendaTimeConvertion::class)]
  353.     private Collection $agendaTimeConvertions;
  355.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Competence::class)]
  356.     private Collection $competences;
  358.     #[ORM\OneToMany(mappedBy: 'prof', targetEntity: ProfTime::class)]
  359.     private Collection $profTimes;
  361.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: GlobalSchoolBreak::class)]
  362.     private Collection $globalSchoolBreaks;
  364.     #[ORM\OneToMany(mappedBy: 'teacher', targetEntity: TeacherAbsence::class)]
  365.     private Collection $teacherAbsences;
  367.     #[ORM\OneToMany(mappedBy: 'teacher', targetEntity: TeacherActivity::class, orphanRemoval: true)]
  368.     private Collection $teacherActivities;
  370.     #[ORM\ManyToOne(inversedBy: 'users')]
  371.     private ?Region $regionInspect = null;
  373.     #[ORM\ManyToOne(inversedBy: 'users')]
  374.     private ?Department $departmentInspect = null;
  376.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserDevice::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
  377.     private Collection $devices;
  379.     public function __toString(): string
  380.     {
  381.         return $this->getFullName();
  382.     }
  384.     public function __construct()
  385.     {
  386.         $this->news = new ArrayCollection();
  387.         $this->events = new ArrayCollection();
  388.         $this->userYears = new ArrayCollection();
  389.         $this->subjects = new ArrayCollection();
  390.         $this->students = new ArrayCollection();
  391.         $this->homeWorks = new ArrayCollection();
  392.         $this->chats = new ArrayCollection();
  393.         $this->messages = new ArrayCollection();
  394.         $this->docInfos = new ArrayCollection();
  395.         $this->docInfoUpdated = new ArrayCollection();
  396.         $this->parentDocInfos = new ArrayCollection();
  397.         $this->discussions = new ArrayCollection();
  398.         $this->discussionMessages = new ArrayCollection();
  399.         $this->notifications = new ArrayCollection();
  400.         $this->absences = new ArrayCollection();
  401.         $this->absencesEdited = new ArrayCollection();
  402.         $this->categoryEvents = new ArrayCollection();
  403.         $this->categoryEventsEdited = new ArrayCollection();
  404.         $this->classYears = new ArrayCollection();
  405.         $this->ClassYearsEdited = new ArrayCollection();
  406.         $this->eventsEdited = new ArrayCollection();
  407.         $this->exams = new ArrayCollection();
  408.         $this->examsEdited = new ArrayCollection();
  409.         $this->homeworksEdited = new ArrayCollection();
  410.         $this->lates = new ArrayCollection();
  411.         $this->latesEdited = new ArrayCollection();
  412.         $this->newsCategories = new ArrayCollection();
  413.         $this->newsCategoriesEdited = new ArrayCollection();
  414.         $this->notes = new ArrayCollection();
  415.         $this->notesEdited = new ArrayCollection();
  416.         $this->schoolSections = new ArrayCollection();
  417.         $this->schoolSectionsEdited = new ArrayCollection();
  418.         $this->schoolYears = new ArrayCollection();
  419.         $this->schoolYearsEdited = new ArrayCollection();
  420.         $this->studentsEdited = new ArrayCollection();
  421.         $this->subjectsEdited = new ArrayCollection();
  422.         $this->subjectGroups = new ArrayCollection();
  423.         $this->subjectGroupsEdited = new ArrayCollection();
  424.         $this->theClasses = new ArrayCollection();
  425.         $this->theClassesEdited = new ArrayCollection();
  426.         $this->users = new ArrayCollection();
  427.         $this->usersEdited = new ArrayCollection();
  428.         $this->studentsCreated = new ArrayCollection();
  429.         $this->subjectsCreated = new ArrayCollection();
  430.         $this->newsEdited = new ArrayCollection();
  431.         $this->punishes = new ArrayCollection();
  432.         $this->punishCategories = new ArrayCollection();
  433.         $this->discussionClassMessages = new ArrayCollection();
  434.         $this->agendas = new ArrayCollection();
  435.         $this->examAgendas = new ArrayCollection();
  436.         $this->subSequences = new ArrayCollection();
  437.         $this->quarters = new ArrayCollection();
  438.         $this->subNotes = new ArrayCollection();
  439.         $this->agendaDays = new ArrayCollection();
  440.         $this->agendaElements = new ArrayCollection();
  441.         $this->examAgendaDays = new ArrayCollection();
  442.         $this->examAgendaElements = new ArrayCollection();
  443.         $this->appreciations = new ArrayCollection();
  444.         $this->localAccounts = new ArrayCollection();
  445.         $this->scolarityHistories = new ArrayCollection();
  446.         $this->scolarityHistoryEditions = new ArrayCollection();
  447.         $this->justifyAbsences = new ArrayCollection();
  448.         $this->verbalProcesses = new ArrayCollection();
  449.         $this->absenceDisciplineConcileConfigs = new ArrayCollection();
  450.         $this->theClassesTeached = new ArrayCollection();
  451.         $this->primaryNotes = new ArrayCollection();
  452.         $this->verbalProcessCategories = new ArrayCollection();
  453.         $this->newsBookmarks = new ArrayCollection();
  454.         $this->homeworkBookmarks = new ArrayCollection();
  455.         $this->userAndroidTokens = new ArrayCollection();
  456.         $this->userIphoneTokens = new ArrayCollection();
  457.         $this->absenceBlameConfigs = new ArrayCollection();
  458.         $this->absenceWarningConfigs = new ArrayCollection();
  459.         $this->absencePunishConfigs = new ArrayCollection();
  460.         $this->absenceExclusionConfigs = new ArrayCollection();
  461.         $this->globalDisciplineEnabledConfigs = new ArrayCollection();
  462.         $this->absenceRetainedConfigs = new ArrayCollection();
  463.         $this->disciplineConciles = new ArrayCollection();
  464.         $this->refreshTokens = new ArrayCollection();
  465.         $this->userNotifications = new ArrayCollection();
  466.         $this->discussionClassMessagesRead = new ArrayCollection();
  467.         $this->agendaTimeConvertions = new ArrayCollection();
  468.         $this->competences = new ArrayCollection();
  469.         $this->profTimes = new ArrayCollection();
  470.         $this->globalSchoolBreaks = new ArrayCollection();
  471.         $this->teacherAbsences = new ArrayCollection();
  472.         $this->teacherActivities = new ArrayCollection();
  473.         $this->devices = new ArrayCollection();
  474.     }
  476.     public function getFullName():string
  477.     {
  478.         return $this->getLastName()." ".$this->getFirstName();
  479.     }
  481.     public function getId(): ?int
  482.     {
  483.         return $this->id;
  484.     }
  486.     public function getEmail(): ?string
  487.     {
  488.         return $this->email;
  489.     }
  491.     public function setEmail(string $email): static
  492.     {
  493.         $this->email = $email;
  495.         return $this;
  496.     }
  498.     /**
  499.      * A visual identifier that represents this user.
  500.      *
  501.      * @see UserInterface
  502.      */
  503.     public function getUserIdentifier(): string
  504.     {
  505.         return (string) $this->email;
  506.     }
  508.     /**
  509.      * @see UserInterface
  510.      */
  511.     public function getRoles(): array
  512.     {
  513.         $roles = $this->roles;
  514.         // guarantee every user at least has ROLE_USER
  515.         $roles[] = 'ROLE_USER';
  517.         return array_unique($roles);
  518.     }
  520.     public function setRoles(array $roles): static
  521.     {
  522.         $this->roles = $roles;
  524.         return $this;
  525.     }
  527.     /**
  528.      * @see PasswordAuthenticatedUserInterface
  529.      */
  530.     public function getPassword(): string
  531.     {
  532.         return $this->password;
  533.     }
  535.     public function setPassword(string $password): static
  536.     {
  537.         $this->password = $password;
  539.         return $this;
  540.     }
  542.     /**
  543.      * @see UserInterface
  544.      */
  545.     public function eraseCredentials(): void
  546.     {
  547.         // If you store any temporary, sensitive data on the user, clear it here
  548.         // $this->plainPassword = null;
  549.     }
  551.     public function getFirstName(): ?string
  552.     {
  553.         return $this->firstName;
  554.     }
  556.     public function setFirstName(string $firstName): static
  557.     {
  558.         $this->firstName = $firstName;
  560.         return $this;
  561.     }
  563.     public function getLastName(): ?string
  564.     {
  565.         return $this->lastName;
  566.     }
  568.     public function setLastName(string $lastName): static
  569.     {
  570.         $this->lastName = $lastName;
  572.         return $this;
  573.     }
  575.     public function getPhone(): ?string
  576.     {
  577.         return $this->phone;
  578.     }
  580.     public function setPhone(string $phone): static
  581.     {
  582.         $this->phone = $phone;
  584.         return $this;
  585.     }
  587.     public function getUserType(): ?string
  588.     {
  589.         return $this->userType;
  590.     }
  592.     public function setUserType(string $userType): static
  593.     {
  594.         $this->userType = $userType;
  596.         return $this;
  597.     }
  599.     public function isVerified(): bool
  600.     {
  601.         return $this->isVerified;
  602.     }
  604.     public function setIsVerified(bool $isVerified): static
  605.     {
  606.         $this->isVerified = $isVerified;
  608.         return $this;
  609.     }
  611.     public function isActive(): bool
  612.     {
  613.         return $this->active;
  614.     }
  616.     public function setActive(bool $active): static
  617.     {
  618.         $this->active = $active;
  620.         return $this;
  621.     }
  623.     /**
  624.      * @return Collection<int, News>
  625.      */
  626.     public function getNews(): Collection
  627.     {
  628.         return $this->news;
  629.     }
  631.     public function addNews(News $news): static
  632.     {
  633.         if (!$this->news->contains($news)) {
  634.             $this->news->add($news);
  635.             $news->setAuthor($this);
  636.         }
  638.         return $this;
  639.     }
  641.     public function removeNews(News $news): static
  642.     {
  643.         if ($this->news->removeElement($news)) {
  644.             // set the owning side to null (unless already changed)
  645.             if ($news->getAuthor() === $this) {
  646.                 $news->setAuthor(null);
  647.             }
  648.         }
  650.         return $this;
  651.     }
  653.     /**
  654.      * @return Collection<int, Event>
  655.      */
  656.     public function getEvents(): Collection
  657.     {
  658.         return $this->events;
  659.     }
  661.     public function addEvent(Event $event): static
  662.     {
  663.         if (!$this->events->contains($event)) {
  664.             $this->events->add($event);
  665.             $event->setAuthor($this);
  666.         }
  668.         return $this;
  669.     }
  671.     public function removeEvent(Event $event): static
  672.     {
  673.         if ($this->events->removeElement($event)) {
  674.             // set the owning side to null (unless already changed)
  675.             if ($event->getAuthor() === $this) {
  676.                 $event->setAuthor(null);
  677.             }
  678.         }
  680.         return $this;
  681.     }
  683.     /**
  684.      * @return Collection<int, UserYear>
  685.      */
  686.     public function getUserYears(): Collection
  687.     {
  688.         return $this->userYears;
  689.     }
  691.     public function addUserYear(UserYear $userYear): static
  692.     {
  693.         if (!$this->userYears->contains($userYear)) {
  694.             $this->userYears->add($userYear);
  695.             $userYear->setUser($this);
  696.         }
  698.         return $this;
  699.     }
  701.     public function removeUserYear(UserYear $userYear): static
  702.     {
  703.         if ($this->userYears->removeElement($userYear)) {
  704.             // set the owning side to null (unless already changed)
  705.             if ($userYear->getUser() === $this) {
  706.                 $userYear->setUser(null);
  707.             }
  708.         }
  710.         return $this;
  711.     }
  713.     public function getMatricule(): ?string
  714.     {
  715.         return $this->matricule;
  716.     }
  718.     public function setMatricule(?string $matricule): static
  719.     {
  720.         $this->matricule = $matricule;
  722.         return $this;
  723.     }
  725.     /**
  726.      * @return Collection<int, Subject>
  727.      */
  728.     public function getSubjects(): Collection
  729.     {
  730.         return $this->subjects;
  731.     }
  733.     public function addSubject(Subject $subject): static
  734.     {
  735.         if (!$this->subjects->contains($subject)) {
  736.             $this->subjects->add($subject);
  737.             $subject->setProf($this);
  738.         }
  740.         return $this;
  741.     }
  743.     public function removeSubject(Subject $subject): static
  744.     {
  745.         if ($this->subjects->removeElement($subject)) {
  746.             // set the owning side to null (unless already changed)
  747.             if ($subject->getProf() === $this) {
  748.                 $subject->setProf(null);
  749.             }
  750.         }
  752.         return $this;
  753.     }
  755.     /**
  756.      * @return Collection<int, Student>
  757.      */
  758.     public function getStudents(): Collection
  759.     {
  760.         return $this->students;
  761.     }
  763.     public function getStudentProfile(): ?Student
  764.     {
  765.         return $this->studentProfile;
  766.     }
  768.     public function addStudent(Student $student): static
  769.     {
  770.         if (!$this->students->contains($student)) {
  771.             $this->students->add($student);
  772.             $student->setParent($this);
  773.         }
  775.         return $this;
  776.     }
  778.     public function removeStudent(Student $student): static
  779.     {
  780.         if ($this->students->removeElement($student)) {
  781.             // set the owning side to null (unless already changed)
  782.             if ($student->getParent() === $this) {
  783.                 $student->setParent(null);
  784.             }
  785.         }
  787.         return $this;
  788.     }
  790.     /**
  791.      * @return Collection<int, HomeWork>
  792.      */
  793.     public function getHomeWorks(): Collection
  794.     {
  795.         return $this->homeWorks;
  796.     }
  798.     public function addHomeWork(HomeWork $homeWork): static
  799.     {
  800.         if (!$this->homeWorks->contains($homeWork)) {
  801.             $this->homeWorks->add($homeWork);
  802.             $homeWork->setAuthor($this);
  803.         }
  805.         return $this;
  806.     }
  808.     public function removeHomeWork(HomeWork $homeWork): static
  809.     {
  810.         if ($this->homeWorks->removeElement($homeWork)) {
  811.             // set the owning side to null (unless already changed)
  812.             if ($homeWork->getAuthor() === $this) {
  813.                 $homeWork->setAuthor(null);
  814.             }
  815.         }
  817.         return $this;
  818.     }
  820.     /**
  821.      * @return Collection<int, Chat>
  822.      */
  823.     public function getChats(): Collection
  824.     {
  825.         return $this->chats;
  826.     }
  828.     public function addChat(Chat $chat): static
  829.     {
  830.         if (!$this->chats->contains($chat)) {
  831.             $this->chats->add($chat);
  832.             $chat->setInitiator($this);
  833.         }
  835.         return $this;
  836.     }
  838.     public function removeChat(Chat $chat): static
  839.     {
  840.         if ($this->chats->removeElement($chat)) {
  841.             // set the owning side to null (unless already changed)
  842.             if ($chat->getInitiator() === $this) {
  843.                 $chat->setInitiator(null);
  844.             }
  845.         }
  847.         return $this;
  848.     }
  850.     /**
  851.      * @return Collection<int, Message>
  852.      */
  853.     public function getMessages(): Collection
  854.     {
  855.         return $this->messages;
  856.     }
  858.     public function addMessage(Message $message): static
  859.     {
  860.         if (!$this->messages->contains($message)) {
  861.             $this->messages->add($message);
  862.             $message->setAuthor($this);
  863.         }
  865.         return $this;
  866.     }
  868.     public function removeMessage(Message $message): static
  869.     {
  870.         if ($this->messages->removeElement($message)) {
  871.             // set the owning side to null (unless already changed)
  872.             if ($message->getAuthor() === $this) {
  873.                 $message->setAuthor(null);
  874.             }
  875.         }
  877.         return $this;
  878.     }
  880.     /* @return Collection<int, Discussion>
  881.     */
  882.     public function getDiscussions(): Collection
  883.     {
  884.         return $this->discussions;
  885.     }
  887.     public function addDiscussion(Discussion $discussion): static
  888.     {
  889.         if (!$this->discussions->contains($discussion)) {
  890.             $this->discussions->add($discussion);
  891.             $discussion->setUserA($this);
  892.         }
  894.         return $this;
  895.     }
  897.     public function removeDiscussion(Discussion $discussion): static
  898.     {
  899.         if ($this->discussions->removeElement($discussion)) {
  900.             // set the owning side to null (unless already changed)
  901.             if ($discussion->getUserA() === $this) {
  902.                 $discussion->setUserA(null);
  903.             }
  904.         }
  906.         return $this;
  907.     }
  909.     /**
  910.      * @return Collection<int, DocInfo>
  911.      */
  912.     public function getDocInfos(): Collection
  913.     {
  914.         return $this->docInfos;
  915.     }
  917.     public function addDocInfo(DocInfo $docInfo): static
  918.     {
  919.         if (!$this->docInfos->contains($docInfo)) {
  920.             $this->docInfos->add($docInfo);
  921.             $docInfo->setAuthor($this);
  922.         }
  924.         return $this;
  925.     }
  927.     public function removeDocInfo(DocInfo $docInfo): static
  928.     {
  929.         if ($this->docInfos->removeElement($docInfo)) {
  930.             // set the owning side to null (unless already changed)
  931.             if ($docInfo->getAuthor() === $this) {
  932.                 $docInfo->setAuthor(null);
  933.             }
  934.         }
  936.         return $this;
  937.     }
  939.     /**
  940.      * @return Collection<int, DocInfo>
  941.      */
  942.     public function getDocInfoUpdated(): Collection
  943.     {
  944.         return $this->docInfoUpdated;
  945.     }
  947.     public function addDocInfoUpdated(DocInfo $docInfoUpdated): static
  948.     {
  949.         if (!$this->docInfoUpdated->contains($docInfoUpdated)) {
  950.             $this->docInfoUpdated->add($docInfoUpdated);
  951.             $docInfoUpdated->setEditor($this);
  952.         }
  954.         return $this;
  955.     }
  957.     public function removeDocInfoUpdated(DocInfo $docInfoUpdated): static
  958.     {
  959.         if ($this->docInfoUpdated->removeElement($docInfoUpdated)) {
  960.             // set the owning side to null (unless already changed)
  961.             if ($docInfoUpdated->getEditor() === $this) {
  962.                 $docInfoUpdated->setEditor(null);
  963.             }
  964.         }
  965.         return $this;
  966.     }
  968.     /**
  969.      * @return Collection<int, DocInfo>
  970.      */
  971.     public function getParentDocInfos(): Collection
  972.     {
  973.         return $this->parentDocInfos;
  974.     }
  976.     public function addParentDocInfo(DocInfo $parentDocInfo): static
  977.     {
  978.         if (!$this->parentDocInfos->contains($parentDocInfo)) {
  979.             $this->parentDocInfos->add($parentDocInfo);
  980.             $parentDocInfo->setParent($this);
  981.         }
  983.         return $this;
  984.     }
  986.     public function removeParentDocInfo(DocInfo $parentDocInfo): static
  987.     {
  988.         if ($this->parentDocInfos->removeElement($parentDocInfo)) {
  989.             // set the owning side to null (unless already changed)
  990.             if ($parentDocInfo->getParent() === $this) {
  991.                 $parentDocInfo->setParent(null);
  992.             }
  993.         }
  995.         return $this;
  996.     }
  998.     /* @return Collection<int, DiscussionMessage>
  999.      */
  1000.     public function getDiscussionMessages(): Collection
  1001.     {
  1002.         return $this->discussionMessages;
  1003.     }
  1005.     public function addDiscussionMessage(DiscussionMessage $discussionMessage): static
  1006.     {
  1007.         if (!$this->discussionMessages->contains($discussionMessage)) {
  1008.             $this->discussionMessages->add($discussionMessage);
  1009.             $discussionMessage->setMessageBy($this);
  1010.         }
  1012.         return $this;
  1013.     }
  1014.     public function removeDiscussionMessage(DiscussionMessage $discussionMessage): static
  1015.     {
  1016.         if ($this->discussionMessages->removeElement($discussionMessage)) {
  1017.             // set the owning side to null (unless already changed)
  1018.             if ($discussionMessage->getMessageBy() === $this) {
  1019.                 $discussionMessage->setMessageBy(null);
  1020.             }
  1021.         }
  1023.         return $this;
  1024.     }
  1026.     /* @return Collection<int, Notifications>
  1027.      */
  1028.     public function getNotifications(): Collection
  1029.     {
  1030.         return $this->notifications;
  1031.     }
  1033.     public function addNotification(Notifications $notification): static
  1034.     {
  1035.         if (!$this->notifications->contains($notification)) {
  1036.             $this->notifications->add($notification);
  1037.             $notification->setUser($this);
  1038.         }
  1040.         return $this;
  1041.     }
  1042.     public function removeNotification(Notifications $notification): static
  1043.     {
  1044.         if ($this->notifications->removeElement($notification)) {
  1045.             // set the owning side to null (unless already changed)
  1046.             if ($notification->getUser() === $this) {
  1047.                 $notification->setUser(null);
  1048.             }
  1049.         }
  1051.         return $this;
  1052.     }
  1054.     public function setFullName(?string $fullName): static
  1055.     {
  1056.         $this->fullName = $fullName;
  1058.         return $this;
  1059.     }
  1061.     /**
  1062.      * @return Collection<int, Absence>
  1063.      */
  1064.     public function getAbsences(): Collection
  1065.     {
  1066.         return $this->absences;
  1067.     }
  1069.     public function addAbsence(Absence $absence): static
  1070.     {
  1071.         if (!$this->absences->contains($absence)) {
  1072.             $this->absences->add($absence);
  1073.             $absence->setAuthor($this);
  1074.         }
  1075.         
  1076.         return $this;
  1077.     }
  1079.     /* @return Collection<int, Punish>
  1080.      */
  1081.     public function getPunishes(): Collection
  1082.     {
  1083.         return $this->punishes;
  1084.     }
  1086.     public function addPunish(Punish $punish): static
  1087.     {
  1088.         if (!$this->punishes->contains($punish)) {
  1089.             $this->punishes->add($punish);
  1090.             $punish->setAuthor($this);
  1091.         }
  1093.         return $this;
  1094.     }
  1095.     
  1096.     public function removePunish(Punish $punish): static
  1097.     {
  1098.         if ($this->punishes->removeElement($punish)) {
  1099.             // set the owning side to null (unless already changed)
  1100.             if ($punish->getAuthor() === $this) {
  1101.                 $punish->setAuthor(null);
  1102.             }
  1103.         }
  1105.         return $this;
  1106.     }
  1108.     public function removeAbsence(Absence $absence): static
  1109.     {
  1110.         if ($this->absences->removeElement($absence)) {
  1111.             // set the owning side to null (unless already changed)
  1112.             if ($absence->getAuthor() === $this) {
  1113.                 $absence->setAuthor(null);
  1114.             }
  1115.         }
  1117.         return $this;
  1118.     }
  1120.     /**
  1121.      * @return Collection<int, Absence>
  1122.      */
  1123.     public function getAbsencesEdited(): Collection
  1124.     {
  1125.         return $this->absencesEdited;
  1126.     }
  1128.     public function addAbsencesEdited(Absence $absencesEdited): static
  1129.     {
  1130.         if (!$this->absencesEdited->contains($absencesEdited)) {
  1131.             $this->absencesEdited->add($absencesEdited);
  1132.             $absencesEdited->setEditor($this);
  1133.         }
  1135.         return $this;
  1136.     }
  1138.     public function removeAbsencesEdited(Absence $absencesEdited): static
  1139.     {
  1140.         if ($this->absencesEdited->removeElement($absencesEdited)) {
  1141.             // set the owning side to null (unless already changed)
  1142.             if ($absencesEdited->getEditor() === $this) {
  1143.                 $absencesEdited->setEditor(null);
  1144.             }
  1145.         }
  1147.         return $this;
  1148.     }
  1150.     /**
  1151.      * @return Collection<int, CategoryEvent>
  1152.      */
  1153.     public function getCategoryEvents(): Collection
  1154.     {
  1155.         return $this->categoryEvents;
  1156.     }
  1158.     public function addCategoryEvent(CategoryEvent $categoryEvent): static
  1159.     {
  1160.         if (!$this->categoryEvents->contains($categoryEvent)) {
  1161.             $this->categoryEvents->add($categoryEvent);
  1162.             $categoryEvent->setAuthor($this);
  1163.         }
  1165.         return $this;
  1166.     }
  1168.     public function removeCategoryEvent(CategoryEvent $categoryEvent): static
  1169.     {
  1170.         if ($this->categoryEvents->removeElement($categoryEvent)) {
  1171.             // set the owning side to null (unless already changed)
  1172.             if ($categoryEvent->getAuthor() === $this) {
  1173.                 $categoryEvent->setAuthor(null);
  1174.             }
  1175.         }
  1177.         return $this;
  1178.     }
  1180.     /**
  1181.      * @return Collection<int, CategoryEvent>
  1182.      */
  1183.     public function getCategoryEventsEdited(): Collection
  1184.     {
  1185.         return $this->categoryEventsEdited;
  1186.     }
  1188.     public function addCategoryEventsEdited(CategoryEvent $categoryEventsEdited): static
  1189.     {
  1190.         if (!$this->categoryEventsEdited->contains($categoryEventsEdited)) {
  1191.             $this->categoryEventsEdited->add($categoryEventsEdited);
  1192.             $categoryEventsEdited->setEditor($this);
  1193.         }
  1195.         return $this;
  1196.     }
  1198.     public function removeCategoryEventsEdited(CategoryEvent $categoryEventsEdited): static
  1199.     {
  1200.         if ($this->categoryEventsEdited->removeElement($categoryEventsEdited)) {
  1201.             // set the owning side to null (unless already changed)
  1202.             if ($categoryEventsEdited->getEditor() === $this) {
  1203.                 $categoryEventsEdited->setEditor(null);
  1204.             }
  1205.         }
  1207.         return $this;
  1208.     }
  1210.     /**
  1211.      * @return Collection<int, ClassYear>
  1212.      */
  1213.     public function getClassYears(): Collection
  1214.     {
  1215.         return $this->classYears;
  1216.     }
  1218.     public function addClassYear(ClassYear $classYear): static
  1219.     {
  1220.         if (!$this->classYears->contains($classYear)) {
  1221.             $this->classYears->add($classYear);
  1222.             $classYear->setAuthor($this);
  1223.         }
  1225.         return $this;
  1226.     }
  1228.     public function removeClassYear(ClassYear $classYear): static
  1229.     {
  1230.         if ($this->classYears->removeElement($classYear)) {
  1231.             // set the owning side to null (unless already changed)
  1232.             if ($classYear->getAuthor() === $this) {
  1233.                 $classYear->setAuthor(null);
  1234.             }
  1235.         }
  1237.         return $this;
  1238.     }
  1240.     /**
  1241.      * @return Collection<int, ClassYear>
  1242.      */
  1243.     public function getClassYearsEdited(): Collection
  1244.     {
  1245.         return $this->ClassYearsEdited;
  1246.     }
  1248.     public function addClassYearsEdited(ClassYear $classYearsEdited): static
  1249.     {
  1250.         if (!$this->ClassYearsEdited->contains($classYearsEdited)) {
  1251.             $this->ClassYearsEdited->add($classYearsEdited);
  1252.             $classYearsEdited->setEditor($this);
  1253.         }
  1255.         return $this;
  1256.     }
  1258.     public function removeClassYearsEdited(ClassYear $classYearsEdited): static
  1259.     {
  1260.         if ($this->ClassYearsEdited->removeElement($classYearsEdited)) {
  1261.             // set the owning side to null (unless already changed)
  1262.             if ($classYearsEdited->getEditor() === $this) {
  1263.                 $classYearsEdited->setEditor(null);
  1264.             }
  1265.         }
  1267.         return $this;
  1268.     }
  1270.     /**
  1271.      * @return Collection<int, Event>
  1272.      */
  1273.     public function getEventsEdited(): Collection
  1274.     {
  1275.         return $this->eventsEdited;
  1276.     }
  1278.     public function addEventsEdited(Event $eventsEdited): static
  1279.     {
  1280.         if (!$this->eventsEdited->contains($eventsEdited)) {
  1281.             $this->eventsEdited->add($eventsEdited);
  1282.             $eventsEdited->setEditor($this);
  1283.         }
  1285.         return $this;
  1286.     }
  1288.     public function removeEventsEdited(Event $eventsEdited): static
  1289.     {
  1290.         if ($this->eventsEdited->removeElement($eventsEdited)) {
  1291.             // set the owning side to null (unless already changed)
  1292.             if ($eventsEdited->getEditor() === $this) {
  1293.                 $eventsEdited->setEditor(null);
  1294.             }
  1295.         }
  1297.         return $this;
  1298.     }
  1300.     /**
  1301.      * @return Collection<int, Exams>
  1302.      */
  1303.     public function getExams(): Collection
  1304.     {
  1305.         return $this->exams;
  1306.     }
  1308.     public function addExam(Exams $exam): static
  1309.     {
  1310.         if (!$this->exams->contains($exam)) {
  1311.             $this->exams->add($exam);
  1312.             $exam->setAuthor($this);
  1313.         }
  1315.         return $this;
  1316.     }
  1318.     public function removeExam(Exams $exam): static
  1319.     {
  1320.         if ($this->exams->removeElement($exam)) {
  1321.             // set the owning side to null (unless already changed)
  1322.             if ($exam->getAuthor() === $this) {
  1323.                 $exam->setAuthor(null);
  1324.             }
  1325.         }
  1327.         return $this;
  1328.     }
  1330.     /**
  1331.      * @return Collection<int, Exams>
  1332.      */
  1333.     public function getExamsEdited(): Collection
  1334.     {
  1335.         return $this->examsEdited;
  1336.     }
  1338.     public function addExamsEdited(Exams $examsEdited): static
  1339.     {
  1340.         if (!$this->examsEdited->contains($examsEdited)) {
  1341.             $this->examsEdited->add($examsEdited);
  1342.             $examsEdited->setEditor($this);
  1343.         }
  1345.         return $this;
  1346.     }
  1348.     public function removeExamsEdited(Exams $examsEdited): static
  1349.     {
  1350.         if ($this->examsEdited->removeElement($examsEdited)) {
  1351.             // set the owning side to null (unless already changed)
  1352.             if ($examsEdited->getEditor() === $this) {
  1353.                 $examsEdited->setEditor(null);
  1354.             }
  1355.         }
  1357.         return $this;
  1358.     }
  1360.     /**
  1361.      * @return Collection<int, HomeWork>
  1362.      */
  1363.     public function getHomeworksEdited(): Collection
  1364.     {
  1365.         return $this->homeworksEdited;
  1366.     }
  1368.     public function addHomeworksEdited(HomeWork $homeworksEdited): static
  1369.     {
  1370.         if (!$this->homeworksEdited->contains($homeworksEdited)) {
  1371.             $this->homeworksEdited->add($homeworksEdited);
  1372.             $homeworksEdited->setEditor($this);
  1373.         }
  1375.         return $this;
  1376.     }
  1378.     public function removeHomeworksEdited(HomeWork $homeworksEdited): static
  1379.     {
  1380.         if ($this->homeworksEdited->removeElement($homeworksEdited)) {
  1381.             // set the owning side to null (unless already changed)
  1382.             if ($homeworksEdited->getEditor() === $this) {
  1383.                 $homeworksEdited->setEditor(null);
  1384.             }
  1385.         }
  1387.         return $this;
  1388.     }
  1390.     /**
  1391.      * @return Collection<int, Late>
  1392.      */
  1393.     public function getLates(): Collection
  1394.     {
  1395.         return $this->lates;
  1396.     }
  1398.     public function addLate(Late $late): static
  1399.     {
  1400.         if (!$this->lates->contains($late)) {
  1401.             $this->lates->add($late);
  1402.             $late->setAuthor($this);
  1403.         }
  1405.         return $this;
  1406.     }
  1408.     public function removeLate(Late $late): static
  1409.     {
  1410.         if ($this->lates->removeElement($late)) {
  1411.             // set the owning side to null (unless already changed)
  1412.             if ($late->getAuthor() === $this) {
  1413.                 $late->setAuthor(null);
  1414.             }
  1415.         }
  1417.         return $this;
  1418.     }
  1420.     /**
  1421.      * @return Collection<int, Late>
  1422.      */
  1423.     public function getLatesEdited(): Collection
  1424.     {
  1425.         return $this->latesEdited;
  1426.     }
  1428.     public function addLatesEdited(Late $latesEdited): static
  1429.     {
  1430.         if (!$this->latesEdited->contains($latesEdited)) {
  1431.             $this->latesEdited->add($latesEdited);
  1432.             $latesEdited->setEditor($this);
  1433.         }
  1435.         return $this;
  1436.     }
  1438.     public function removeLatesEdited(Late $latesEdited): static
  1439.     {
  1440.         if ($this->latesEdited->removeElement($latesEdited)) {
  1441.             // set the owning side to null (unless already changed)
  1442.             if ($latesEdited->getEditor() === $this) {
  1443.                 $latesEdited->setEditor(null);
  1444.             }
  1445.         }
  1447.         return $this;
  1448.     }
  1450.     /**
  1451.      * @return Collection<int, NewsCategory>
  1452.      */
  1453.     public function getNewsCategories(): Collection
  1454.     {
  1455.         return $this->newsCategories;
  1456.     }
  1458.     public function addNewsCategory(NewsCategory $newsCategory): static
  1459.     {
  1460.         if (!$this->newsCategories->contains($newsCategory)) {
  1461.             $this->newsCategories->add($newsCategory);
  1462.             $newsCategory->setAuthor($this);
  1463.         }
  1465.         return $this;
  1466.     }
  1468.     public function removeNewsCategory(NewsCategory $newsCategory): static
  1469.     {
  1470.         if ($this->newsCategories->removeElement($newsCategory)) {
  1471.             // set the owning side to null (unless already changed)
  1472.             if ($newsCategory->getAuthor() === $this) {
  1473.                 $newsCategory->setAuthor(null);
  1474.             }
  1475.         }
  1477.         return $this;
  1478.     }
  1480.     /**
  1481.      * @return Collection<int, NewsCategory>
  1482.      */
  1483.     public function getNewsCategoriesEdited(): Collection
  1484.     {
  1485.         return $this->newsCategoriesEdited;
  1486.     }
  1488.     public function addNewsCategoriesEdited(NewsCategory $newsCategoriesEdited): static
  1489.     {
  1490.         if (!$this->newsCategoriesEdited->contains($newsCategoriesEdited)) {
  1491.             $this->newsCategoriesEdited->add($newsCategoriesEdited);
  1492.             $newsCategoriesEdited->setEditor($this);
  1493.         }
  1495.         return $this;
  1496.     }
  1498.     public function removeNewsCategoriesEdited(NewsCategory $newsCategoriesEdited): static
  1499.     {
  1500.         if ($this->newsCategoriesEdited->removeElement($newsCategoriesEdited)) {
  1501.             // set the owning side to null (unless already changed)
  1502.             if ($newsCategoriesEdited->getEditor() === $this) {
  1503.                 $newsCategoriesEdited->setEditor(null);
  1504.             }
  1505.         }
  1507.         return $this;
  1508.     }
  1510.     /**
  1511.      * @return Collection<int, Note>
  1512.      */
  1513.     public function getNotes(): Collection
  1514.     {
  1515.         return $this->notes;
  1516.     }
  1518.     public function addNote(Note $note): static
  1519.     {
  1520.         if (!$this->notes->contains($note)) {
  1521.             $this->notes->add($note);
  1522.             $note->setAuthor($this);
  1523.         }
  1525.         return $this;
  1526.     }
  1528.     public function removeNote(Note $note): static
  1529.     {
  1530.         if ($this->notes->removeElement($note)) {
  1531.             // set the owning side to null (unless already changed)
  1532.             if ($note->getAuthor() === $this) {
  1533.                 $note->setAuthor(null);
  1534.             }
  1535.         }
  1537.         return $this;
  1538.     }
  1540.     /**
  1541.      * @return Collection<int, Note>
  1542.      */
  1543.     public function getNotesEdited(): Collection
  1544.     {
  1545.         return $this->notesEdited;
  1546.     }
  1548.     public function addNotesEdited(Note $notesEdited): static
  1549.     {
  1550.         if (!$this->notesEdited->contains($notesEdited)) {
  1551.             $this->notesEdited->add($notesEdited);
  1552.             $notesEdited->setEditor($this);
  1553.         }
  1555.         return $this;
  1556.     }
  1558.     public function removeNotesEdited(Note $notesEdited): static
  1559.     {
  1560.         if ($this->notesEdited->removeElement($notesEdited)) {
  1561.             // set the owning side to null (unless already changed)
  1562.             if ($notesEdited->getEditor() === $this) {
  1563.                 $notesEdited->setEditor(null);
  1564.             }
  1565.         }
  1567.         return $this;
  1568.     }
  1570.     /**
  1571.      * @return Collection<int, SchoolSection>
  1572.      */
  1573.     public function getSchoolSections(): Collection
  1574.     {
  1575.         return $this->schoolSections;
  1576.     }
  1578.     public function addSchoolSection(SchoolSection $schoolSection): static
  1579.     {
  1580.         if (!$this->schoolSections->contains($schoolSection)) {
  1581.             $this->schoolSections->add($schoolSection);
  1582.             $schoolSection->setAuthor($this);
  1583.         }
  1585.         return $this;
  1586.     }
  1588.     public function removeSchoolSection(SchoolSection $schoolSection): static
  1589.     {
  1590.         if ($this->schoolSections->removeElement($schoolSection)) {
  1591.             // set the owning side to null (unless already changed)
  1592.             if ($schoolSection->getAuthor() === $this) {
  1593.                 $schoolSection->setAuthor(null);
  1594.             }
  1595.         }
  1597.         return $this;
  1598.     }
  1600.     /**
  1601.      * @return Collection<int, SchoolSection>
  1602.      */
  1603.     public function getSchoolSectionsEdited(): Collection
  1604.     {
  1605.         return $this->schoolSectionsEdited;
  1606.     }
  1608.     public function addSchoolSectionsEdited(SchoolSection $schoolSectionsEdited): static
  1609.     {
  1610.         if (!$this->schoolSectionsEdited->contains($schoolSectionsEdited)) {
  1611.             $this->schoolSectionsEdited->add($schoolSectionsEdited);
  1612.             $schoolSectionsEdited->setEditor($this);
  1613.         }
  1615.         return $this;
  1616.     }
  1618.     public function removeSchoolSectionsEdited(SchoolSection $schoolSectionsEdited): static
  1619.     {
  1620.         if ($this->schoolSectionsEdited->removeElement($schoolSectionsEdited)) {
  1621.             // set the owning side to null (unless already changed)
  1622.             if ($schoolSectionsEdited->getEditor() === $this) {
  1623.                 $schoolSectionsEdited->setEditor(null);
  1624.             }
  1625.         }
  1627.         return $this;
  1628.     }
  1630.     /**
  1631.      * @return Collection<int, SchoolYear>
  1632.      */
  1633.     public function getSchoolYears(): Collection
  1634.     {
  1635.         return $this->schoolYears;
  1636.     }
  1638.     public function addSchoolYear(SchoolYear $schoolYear): static
  1639.     {
  1640.         if (!$this->schoolYears->contains($schoolYear)) {
  1641.             $this->schoolYears->add($schoolYear);
  1642.             $schoolYear->setAuthor($this);
  1643.         }
  1645.         return $this;
  1646.     }
  1648.     public function removeSchoolYear(SchoolYear $schoolYear): static
  1649.     {
  1650.         if ($this->schoolYears->removeElement($schoolYear)) {
  1651.             // set the owning side to null (unless already changed)
  1652.             if ($schoolYear->getAuthor() === $this) {
  1653.                 $schoolYear->setAuthor(null);
  1654.             }
  1655.         }
  1657.         return $this;
  1658.     }
  1660.     /**
  1661.      * @return Collection<int, SchoolYear>
  1662.      */
  1663.     public function getSchoolYearsEdited(): Collection
  1664.     {
  1665.         return $this->schoolYearsEdited;
  1666.     }
  1668.     public function addSchoolYearsEdited(SchoolYear $schoolYearsEdited): static
  1669.     {
  1670.         if (!$this->schoolYearsEdited->contains($schoolYearsEdited)) {
  1671.             $this->schoolYearsEdited->add($schoolYearsEdited);
  1672.             $schoolYearsEdited->setEditor($this);
  1673.         }
  1675.         return $this;
  1676.     }
  1678.     public function removeSchoolYearsEdited(SchoolYear $schoolYearsEdited): static
  1679.     {
  1680.         if ($this->schoolYearsEdited->removeElement($schoolYearsEdited)) {
  1681.             // set the owning side to null (unless already changed)
  1682.             if ($schoolYearsEdited->getEditor() === $this) {
  1683.                 $schoolYearsEdited->setEditor(null);
  1684.             }
  1685.         }
  1687.         return $this;
  1688.     }
  1690.     /**
  1691.      * @return Collection<int, Student>
  1692.      */
  1693.     public function getStudentsEdited(): Collection
  1694.     {
  1695.         return $this->studentsEdited;
  1696.     }
  1698.     public function addStudentsEdited(Student $studentsEdited): static
  1699.     {
  1700.         if (!$this->studentsEdited->contains($studentsEdited)) {
  1701.             $this->studentsEdited->add($studentsEdited);
  1702.             $studentsEdited->setEditor($this);
  1703.         }
  1705.         return $this;
  1706.     }
  1708.     public function removeStudentsEdited(Student $studentsEdited): static
  1709.     {
  1710.         if ($this->studentsEdited->removeElement($studentsEdited)) {
  1711.             // set the owning side to null (unless already changed)
  1712.             if ($studentsEdited->getEditor() === $this) {
  1713.                 $studentsEdited->setEditor(null);
  1714.             }
  1715.         }
  1717.         return $this;
  1718.     }
  1720.     /**
  1721.      * @return Collection<int, Subject>
  1722.      */
  1723.     public function getSubjectsEdited(): Collection
  1724.     {
  1725.         return $this->subjectsEdited;
  1726.     }
  1728.     public function addSubjectsEdited(Subject $subjectsEdited): static
  1729.     {
  1730.         if (!$this->subjectsEdited->contains($subjectsEdited)) {
  1731.             $this->subjectsEdited->add($subjectsEdited);
  1732.             $subjectsEdited->setEditor($this);
  1733.         }
  1735.         return $this;
  1736.     }
  1738.     public function removeSubjectsEdited(Subject $subjectsEdited): static
  1739.     {
  1740.         if ($this->subjectsEdited->removeElement($subjectsEdited)) {
  1741.             // set the owning side to null (unless already changed)
  1742.             if ($subjectsEdited->getEditor() === $this) {
  1743.                 $subjectsEdited->setEditor(null);
  1744.             }
  1745.         }
  1747.         return $this;
  1748.     }
  1750.     /**
  1751.      * @return Collection<int, SubjectGroup>
  1752.      */
  1753.     public function getSubjectGroups(): Collection
  1754.     {
  1755.         return $this->subjectGroups;
  1756.     }
  1758.     public function addSubjectGroup(SubjectGroup $subjectGroup): static
  1759.     {
  1760.         if (!$this->subjectGroups->contains($subjectGroup)) {
  1761.             $this->subjectGroups->add($subjectGroup);
  1762.             $subjectGroup->setAuthor($this);
  1763.         }
  1765.         return $this;
  1766.     }
  1768.     public function removeSubjectGroup(SubjectGroup $subjectGroup): static
  1769.     {
  1770.         if ($this->subjectGroups->removeElement($subjectGroup)) {
  1771.             // set the owning side to null (unless already changed)
  1772.             if ($subjectGroup->getAuthor() === $this) {
  1773.                 $subjectGroup->setAuthor(null);
  1774.             }
  1775.         }
  1777.         return $this;
  1778.     }
  1780.     /**
  1781.      * @return Collection<int, SubjectGroup>
  1782.      */
  1783.     public function getSubjectGroupsEdited(): Collection
  1784.     {
  1785.         return $this->subjectGroupsEdited;
  1786.     }
  1788.     public function addSubjectGroupsEdited(SubjectGroup $subjectGroupsEdited): static
  1789.     {
  1790.         if (!$this->subjectGroupsEdited->contains($subjectGroupsEdited)) {
  1791.             $this->subjectGroupsEdited->add($subjectGroupsEdited);
  1792.             $subjectGroupsEdited->setEditor($this);
  1793.         }
  1795.         return $this;
  1796.     }
  1798.     public function removeSubjectGroupsEdited(SubjectGroup $subjectGroupsEdited): static
  1799.     {
  1800.         if ($this->subjectGroupsEdited->removeElement($subjectGroupsEdited)) {
  1801.             // set the owning side to null (unless already changed)
  1802.             if ($subjectGroupsEdited->getEditor() === $this) {
  1803.                 $subjectGroupsEdited->setEditor(null);
  1804.             }
  1805.         }
  1807.         return $this;
  1808.     }
  1810.     /**
  1811.      * @return Collection<int, TheClass>
  1812.      */
  1813.     public function getTheClasses(): Collection
  1814.     {
  1815.         return $this->theClasses;
  1816.     }
  1818.     public function addTheClass(TheClass $theClass): static
  1819.     {
  1820.         if (!$this->theClasses->contains($theClass)) {
  1821.             $this->theClasses->add($theClass);
  1822.             $theClass->setAuthor($this);
  1823.         }
  1825.         return $this;
  1826.     }
  1828.     public function removeTheClass(TheClass $theClass): static
  1829.     {
  1830.         if ($this->theClasses->removeElement($theClass)) {
  1831.             // set the owning side to null (unless already changed)
  1832.             if ($theClass->getAuthor() === $this) {
  1833.                 $theClass->setAuthor(null);
  1834.             }
  1835.         }
  1837.         return $this;
  1838.     }
  1840.     /**
  1841.      * @return Collection<int, TheClass>
  1842.      */
  1843.     public function getTheClassesEdited(): Collection
  1844.     {
  1845.         return $this->theClassesEdited;
  1846.     }
  1848.     public function addTheClassesEdited(TheClass $theClassesEdited): static
  1849.     {
  1850.         if (!$this->theClassesEdited->contains($theClassesEdited)) {
  1851.             $this->theClassesEdited->add($theClassesEdited);
  1852.             $theClassesEdited->setEditor($this);
  1853.         }
  1855.         return $this;
  1856.     }
  1858.     public function removeTheClassesEdited(TheClass $theClassesEdited): static
  1859.     {
  1860.         if ($this->theClassesEdited->removeElement($theClassesEdited)) {
  1861.             // set the owning side to null (unless already changed)
  1862.             if ($theClassesEdited->getEditor() === $this) {
  1863.                 $theClassesEdited->setEditor(null);
  1864.             }
  1865.         }
  1867.         return $this;
  1868.     }
  1870.     public function getAuthor(): ?self
  1871.     {
  1872.         return $this->author;
  1873.     }
  1875.     public function setAuthor(?self $author): static
  1876.     {
  1877.         $this->author = $author;
  1879.         return $this;
  1880.     }
  1882.     /**
  1883.      * @return Collection<int, self>
  1884.      */
  1885.     public function getUsers(): Collection
  1886.     {
  1887.         return $this->users;
  1888.     }
  1890.     public function addUser(self $user): static
  1891.     {
  1892.         if (!$this->users->contains($user)) {
  1893.             $this->users->add($user);
  1894.             $user->setAuthor($this);
  1895.         }
  1897.         return $this;
  1898.     }
  1900.     public function removeUser(self $user): static
  1901.     {
  1902.         if ($this->users->removeElement($user)) {
  1903.             // set the owning side to null (unless already changed)
  1904.             if ($user->getAuthor() === $this) {
  1905.                 $user->setAuthor(null);
  1906.             }
  1907.         }
  1909.         return $this;
  1910.     }
  1912.     public function getEditor(): ?self
  1913.     {
  1914.         return $this->editor;
  1915.     }
  1917.     public function setEditor(?self $editor): static
  1918.     {
  1919.         $this->editor = $editor;
  1921.         return $this;
  1922.     }
  1924.     /**
  1925.      * @return Collection<int, self>
  1926.      */
  1927.     public function getUsersEdited(): Collection
  1928.     {
  1929.         return $this->usersEdited;
  1930.     }
  1932.     public function addUsersEdited(self $usersEdited): static
  1933.     {
  1934.         if (!$this->usersEdited->contains($usersEdited)) {
  1935.             $this->usersEdited->add($usersEdited);
  1936.             $usersEdited->setEditor($this);
  1937.         }
  1939.         return $this;
  1940.     }
  1942.     public function removeUsersEdited(self $usersEdited): static
  1943.     {
  1944.         if ($this->usersEdited->removeElement($usersEdited)) {
  1945.             // set the owning side to null (unless already changed)
  1946.             if ($usersEdited->getEditor() === $this) {
  1947.                 $usersEdited->setEditor(null);
  1948.             }
  1949.         }
  1951.         return $this;
  1952.     }
  1954.     /**
  1955.      * @return Collection<int, Student>
  1956.      */
  1957.     public function getStudentsCreated(): Collection
  1958.     {
  1959.         return $this->studentsCreated;
  1960.     }
  1962.     public function addStudentsCreated(Student $studentsCreated): static
  1963.     {
  1964.         if (!$this->studentsCreated->contains($studentsCreated)) {
  1965.             $this->studentsCreated->add($studentsCreated);
  1966.             $studentsCreated->setAuthor($this);
  1967.         }
  1969.         return $this;
  1970.     }
  1972.     public function removeStudentsCreated(Student $studentsCreated): static
  1973.     {
  1974.         if ($this->studentsCreated->removeElement($studentsCreated)) {
  1975.             // set the owning side to null (unless already changed)
  1976.             if ($studentsCreated->getAuthor() === $this) {
  1977.                 $studentsCreated->setAuthor(null);
  1978.             }
  1979.         }
  1981.         return $this;
  1982.     }
  1984.     /**
  1985.      * @return Collection<int, Subject>
  1986.      */
  1987.     public function getSubjectsCreated(): Collection
  1988.     {
  1989.         return $this->subjectsCreated;
  1990.     }
  1992.     public function addSubjectsCreated(Subject $subjectsCreated): static
  1993.     {
  1994.         if (!$this->subjectsCreated->contains($subjectsCreated)) {
  1995.             $this->subjectsCreated->add($subjectsCreated);
  1996.             $subjectsCreated->setAuthor($this);
  1997.         }
  1999.         return $this;
  2000.     }
  2002.     public function removeSubjectsCreated(Subject $subjectsCreated): static
  2003.     {
  2004.         if ($this->subjectsCreated->removeElement($subjectsCreated)) {
  2005.             // set the owning side to null (unless already changed)
  2006.             if ($subjectsCreated->getAuthor() === $this) {
  2007.                 $subjectsCreated->setAuthor(null);
  2008.             }
  2009.         }
  2011.         return $this;
  2012.     }
  2014.     /**
  2015.      * @return Collection<int, News>
  2016.      */
  2017.     public function getNewsEdited(): Collection
  2018.     {
  2019.         return $this->newsEdited;
  2020.     }
  2022.     public function addNewsEdited(News $newsEdited): static
  2023.     {
  2024.         if (!$this->newsEdited->contains($newsEdited)) {
  2025.             $this->newsEdited->add($newsEdited);
  2026.             $newsEdited->setEditor($this);
  2027.         }
  2029.         return $this;
  2030.     }
  2032.     public function removeNewsEdited(News $newsEdited): static
  2033.     {
  2034.         if ($this->newsEdited->removeElement($newsEdited)) {
  2035.             // set the owning side to null (unless already changed)
  2036.             if ($newsEdited->getEditor() === $this) {
  2037.                 $newsEdited->setEditor(null);
  2038.             }
  2039.         }
  2041.         return $this;
  2042.     }
  2044.     /**
  2045.      * @return Collection<int, PunishCategory>
  2046.      */
  2047.     public function getPunishCategories(): Collection
  2048.     {
  2049.         return $this->punishCategories;
  2050.     }
  2052.     public function addPunishCategory(PunishCategory $punishCategory): static
  2053.     {
  2054.         if (!$this->punishCategories->contains($punishCategory)) {
  2055.             $this->punishCategories->add($punishCategory);
  2056.             $punishCategory->setAuthor($this);
  2057.         }
  2059.         return $this;
  2060.     }
  2062.     public function removePunishCategory(PunishCategory $punishCategory): static
  2063.     {
  2064.         if ($this->punishCategories->removeElement($punishCategory)) {
  2065.             // set the owning side to null (unless already changed)
  2066.             if ($punishCategory->getAuthor() === $this) {
  2067.                 $punishCategory->setAuthor(null);
  2068.             }
  2069.         }
  2071.         return $this;
  2072.     }
  2074.     public function getLastRequestTs(): ?string
  2075.     {
  2076.         return $this->lastRequestTs;
  2077.     }
  2079.     public function setLastRequestTs(?string $lastRequestTs): static
  2080.     {
  2081.         $this->lastRequestTs = $lastRequestTs;
  2083.         return $this;
  2084.     }
  2086.     public function getSchool(): ?School
  2087.     {
  2088.         return $this->school;
  2089.     }
  2091.     public function setSchool(?School $school): static
  2092.     {
  2093.         $this->school = $school;
  2095.         return $this;
  2096.     }
  2098.     /**
  2099.      * @return Collection<int, DiscussionClassMessage>
  2100.      */
  2101.     public function getDiscussionClassMessages(): Collection
  2102.     {
  2103.         return $this->discussionClassMessages;
  2104.     }
  2106.     public function addDiscussionClassMessage(DiscussionClassMessage $discussionClassMessage): static
  2107.     {
  2108.         if (!$this->discussionClassMessages->contains($discussionClassMessage)) {
  2109.             $this->discussionClassMessages->add($discussionClassMessage);
  2110.             $discussionClassMessage->setAuthor($this);
  2111.         }
  2113.         return $this;
  2114.     }
  2116.     public function removeDiscussionClassMessage(DiscussionClassMessage $discussionClassMessage): static
  2117.     {
  2118.         if ($this->discussionClassMessages->removeElement($discussionClassMessage)) {
  2119.             // set the owning side to null (unless already changed)
  2120.             if ($discussionClassMessage->getAuthor() === $this) {
  2121.                 $discussionClassMessage->setAuthor(null);
  2122.             }
  2123.         }
  2125.         return $this;
  2126.     }
  2128.     /**
  2129.      * @return Collection<int, Agenda>
  2130.      */
  2131.     public function getAgendas(): Collection
  2132.     {
  2133.         return $this->agendas;
  2134.     }
  2136.     public function addAgenda(Agenda $agenda): static
  2137.     {
  2138.         if (!$this->agendas->contains($agenda)) {
  2139.             $this->agendas->add($agenda);
  2140.             $agenda->setAuthor($this);
  2141.         }
  2143.         return $this;
  2144.     }
  2146.     public function removeAgenda(Agenda $agenda): static
  2147.     {
  2148.         if ($this->agendas->removeElement($agenda)) {
  2149.             // set the owning side to null (unless already changed)
  2150.             if ($agenda->getAuthor() === $this) {
  2151.                 $agenda->setAuthor(null);
  2152.             }
  2153.         }
  2155.         return $this;
  2156.     }
  2158.     /**
  2159.      * @return Collection<int, ExamAgenda>
  2160.      */
  2161.     public function getExamAgendas(): Collection
  2162.     {
  2163.         return $this->examAgendas;
  2164.     }
  2166.     public function addExamAgenda(ExamAgenda $examAgenda): static
  2167.     {
  2168.         if (!$this->examAgendas->contains($examAgenda)) {
  2169.             $this->examAgendas->add($examAgenda);
  2170.             $examAgenda->setAuthor($this);
  2171.         }
  2173.         return $this;
  2174.     }
  2176.     public function removeExamAgenda(ExamAgenda $examAgenda): static
  2177.     {
  2178.         if ($this->examAgendas->removeElement($examAgenda)) {
  2179.             // set the owning side to null (unless already changed)
  2180.             if ($examAgenda->getAuthor() === $this) {
  2181.                 $examAgenda->setAuthor(null);
  2182.             }
  2183.         }
  2185.         return $this;
  2186.     }
  2188.     /**
  2189.      * @return Collection<int, SubSequence>
  2190.      */
  2191.     public function getSubSequences(): Collection
  2192.     {
  2193.         return $this->subSequences;
  2194.     }
  2196.     public function addSubSequence(SubSequence $subSequence): static
  2197.     {
  2198.         if (!$this->subSequences->contains($subSequence)) {
  2199.             $this->subSequences->add($subSequence);
  2200.             $subSequence->setAuthor($this);
  2201.         }
  2203.         return $this;
  2204.     }
  2206.     public function removeSubSequence(SubSequence $subSequence): static
  2207.     {
  2208.         if ($this->subSequences->removeElement($subSequence)) {
  2209.             // set the owning side to null (unless already changed)
  2210.             if ($subSequence->getAuthor() === $this) {
  2211.                 $subSequence->setAuthor(null);
  2212.             }
  2213.         }
  2215.         return $this;
  2216.     }
  2218.     /**
  2219.      * @return Collection<int, Quarter>
  2220.      */
  2221.     public function getQuarters(): Collection
  2222.     {
  2223.         return $this->quarters;
  2224.     }
  2226.     public function addQuarter(Quarter $quarter): static
  2227.     {
  2228.         if (!$this->quarters->contains($quarter)) {
  2229.             $this->quarters->add($quarter);
  2230.             $quarter->setAuthor($this);
  2231.         }
  2233.         return $this;
  2234.     }
  2236.     public function removeQuarter(Quarter $quarter): static
  2237.     {
  2238.         if ($this->quarters->removeElement($quarter)) {
  2239.             // set the owning side to null (unless already changed)
  2240.             if ($quarter->getAuthor() === $this) {
  2241.                 $quarter->setAuthor(null);
  2242.             }
  2243.         }
  2245.         return $this;
  2246.     }
  2248.     /**
  2249.      * @return Collection<int, SubNote>
  2250.      */
  2251.     public function getSubNotes(): Collection
  2252.     {
  2253.         return $this->subNotes;
  2254.     }
  2256.     public function addSubNote(SubNote $subNote): static
  2257.     {
  2258.         if (!$this->subNotes->contains($subNote)) {
  2259.             $this->subNotes->add($subNote);
  2260.             $subNote->setAuthor($this);
  2261.         }
  2263.         return $this;
  2264.     }
  2266.     public function removeSubNote(SubNote $subNote): static
  2267.     {
  2268.         if ($this->subNotes->removeElement($subNote)) {
  2269.             // set the owning side to null (unless already changed)
  2270.             if ($subNote->getAuthor() === $this) {
  2271.                 $subNote->setAuthor(null);
  2272.             }
  2273.         }
  2275.         return $this;
  2276.     }
  2278.     /**
  2279.      * @return Collection<int, AgendaDay>
  2280.      */
  2281.     public function getAgendaDays(): Collection
  2282.     {
  2283.         return $this->agendaDays;
  2284.     }
  2286.     public function addAgendaDay(AgendaDay $agendaDay): static
  2287.     {
  2288.         if (!$this->agendaDays->contains($agendaDay)) {
  2289.             $this->agendaDays->add($agendaDay);
  2290.             $agendaDay->setAuthor($this);
  2291.         }
  2293.         return $this;
  2294.     }
  2296.     public function removeAgendaDay(AgendaDay $agendaDay): static
  2297.     {
  2298.         if ($this->agendaDays->removeElement($agendaDay)) {
  2299.             // set the owning side to null (unless already changed)
  2300.             if ($agendaDay->getAuthor() === $this) {
  2301.                 $agendaDay->setAuthor(null);
  2302.             }
  2303.         }
  2305.         return $this;
  2306.     }
  2308.     /**
  2309.      * @return Collection<int, AgendaElement>
  2310.      */
  2311.     public function getAgendaElements(): Collection
  2312.     {
  2313.         return $this->agendaElements;
  2314.     }
  2316.     public function addAgendaElement(AgendaElement $agendaElement): static
  2317.     {
  2318.         if (!$this->agendaElements->contains($agendaElement)) {
  2319.             $this->agendaElements->add($agendaElement);
  2320.             $agendaElement->setAuthor($this);
  2321.         }
  2323.         return $this;
  2324.     }
  2326.     public function removeAgendaElement(AgendaElement $agendaElement): static
  2327.     {
  2328.         if ($this->agendaElements->removeElement($agendaElement)) {
  2329.             // set the owning side to null (unless already changed)
  2330.             if ($agendaElement->getAuthor() === $this) {
  2331.                 $agendaElement->setAuthor(null);
  2332.             }
  2333.         }
  2335.         return $this;
  2336.     }
  2338.     /**
  2339.      * @return Collection<int, ExamAgendaDay>
  2340.      */
  2341.     public function getExamAgendaDays(): Collection
  2342.     {
  2343.         return $this->examAgendaDays;
  2344.     }
  2346.     public function addExamAgendaDay(ExamAgendaDay $examAgendaDay): static
  2347.     {
  2348.         if (!$this->examAgendaDays->contains($examAgendaDay)) {
  2349.             $this->examAgendaDays->add($examAgendaDay);
  2350.             $examAgendaDay->setAuthor($this);
  2351.         }
  2353.         return $this;
  2354.     }
  2356.     public function removeExamAgendaDay(ExamAgendaDay $examAgendaDay): static
  2357.     {
  2358.         if ($this->examAgendaDays->removeElement($examAgendaDay)) {
  2359.             // set the owning side to null (unless already changed)
  2360.             if ($examAgendaDay->getAuthor() === $this) {
  2361.                 $examAgendaDay->setAuthor(null);
  2362.             }
  2363.         }
  2365.         return $this;
  2366.     }
  2368.     /**
  2369.      * @return Collection<int, ExamAgendaElement>
  2370.      */
  2371.     public function getExamAgendaElements(): Collection
  2372.     {
  2373.         return $this->examAgendaElements;
  2374.     }
  2376.     public function addExamAgendaElement(ExamAgendaElement $examAgendaElement): static
  2377.     {
  2378.         if (!$this->examAgendaElements->contains($examAgendaElement)) {
  2379.             $this->examAgendaElements->add($examAgendaElement);
  2380.             $examAgendaElement->setAuthor($this);
  2381.         }
  2383.         return $this;
  2384.     }
  2386.     public function removeExamAgendaElement(ExamAgendaElement $examAgendaElement): static
  2387.     {
  2388.         if ($this->examAgendaElements->removeElement($examAgendaElement)) {
  2389.             // set the owning side to null (unless already changed)
  2390.             if ($examAgendaElement->getAuthor() === $this) {
  2391.                 $examAgendaElement->setAuthor(null);
  2392.             }
  2393.         }
  2395.         return $this;
  2396.     }
  2398.     /**
  2399.      * @return Collection<int, Appreciation>
  2400.      */
  2401.     public function getAppreciations(): Collection
  2402.     {
  2403.         return $this->appreciations;
  2404.     }
  2406.     public function addAppreciation(Appreciation $appreciation): static
  2407.     {
  2408.         if (!$this->appreciations->contains($appreciation)) {
  2409.             $this->appreciations->add($appreciation);
  2410.             $appreciation->setAuthor($this);
  2411.         }
  2412.         return $this;
  2413.     }
  2415.     public function removeAppreciation(Appreciation $appreciation): static
  2416.     {
  2417.         if ($this->appreciations->removeElement($appreciation)) {
  2418.             // set the owning side to null (unless already changed)
  2419.             if ($appreciation->getAuthor() === $this) {
  2420.                 $appreciation->setAuthor(null);
  2421.             }
  2422.         }
  2423.         return $this;
  2424.     }
  2425.     
  2426.     /**
  2427.      * @return Collection<int, LocalAccount>
  2428.      */
  2429.     public function getLocalAccounts(): Collection
  2430.     {
  2431.         return $this->localAccounts;
  2432.     }
  2434.     public function addLocalAccount(LocalAccount $localAccount): static
  2435.     {
  2436.         if (!$this->localAccounts->contains($localAccount)) {
  2437.             $this->localAccounts->add($localAccount);
  2438.             $localAccount->setUser($this);
  2439.         }
  2441.         return $this;
  2442.     }
  2444.     public function removeLocalAccount(LocalAccount $localAccount): static
  2445.     {
  2446.         if ($this->localAccounts->removeElement($localAccount)) {
  2447.             // set the owning side to null (unless already changed)
  2448.             if ($localAccount->getUser() === $this) {
  2449.                 $localAccount->setUser(null);
  2450.             }
  2451.         }
  2453.         return $this;
  2454.     }
  2456.     /**
  2457.      * @return Collection<int, NewsBookmark>
  2458.      */
  2459.     public function getNewsBookmarks(): Collection
  2460.     {
  2461.         return $this->newsBookmarks;
  2462.     }
  2464.     public function addNewsBookmark(NewsBookmark $newsBookmark): static
  2465.     {
  2466.         if (!$this->newsBookmarks->contains($newsBookmark)) {
  2467.             $this->newsBookmarks->add($newsBookmark);
  2468.             $newsBookmark->setUser($this);
  2469.         }
  2470.         return $this;
  2471.     }
  2473.     /**
  2474.      * @return Collection<int, ScolarityHistory>
  2475.      */
  2476.     public function getScolarityHistories(): Collection
  2477.     {
  2478.         return $this->scolarityHistories;
  2479.     }
  2481.     public function addScolarityHistory(ScolarityHistory $scolarityHistory): static
  2482.     {
  2483.         if (!$this->scolarityHistories->contains($scolarityHistory)) {
  2484.             $this->scolarityHistories->add($scolarityHistory);
  2485.             $scolarityHistory->setAuthor($this);
  2486.         }
  2488.         return $this;
  2489.     }
  2492.     public function removeNewsBookmark(NewsBookmark $newsBookmark): static
  2493.     {
  2494.         if ($this->newsBookmarks->removeElement($newsBookmark)) {
  2495.             // set the owning side to null (unless already changed)
  2496.             if ($newsBookmark->getUser() === $this) {
  2497.                 $newsBookmark->setUser(null);
  2498.             }
  2499.             return $this;
  2500.         }
  2501.     }
  2503.     public function removeScolarityHistory(ScolarityHistory $scolarityHistory): static
  2504.     {
  2505.         if ($this->scolarityHistories->removeElement($scolarityHistory)) {
  2506.             // set the owning side to null (unless already changed)
  2507.             if ($scolarityHistory->getAuthor() === $this) {
  2508.                 $scolarityHistory->setAuthor(null);
  2509.             }
  2510.         }
  2512.         return $this;
  2513.     }
  2515.     /**
  2516.      * @return Collection<int, HomeworkBookmark>
  2517.      */
  2518.     public function getHomeworkBookmarks(): Collection
  2519.     {
  2520.         return $this->homeworkBookmarks;
  2521.     }
  2523.     public function addHomeworkBookmark(HomeworkBookmark $homeworkBookmark): static
  2524.     {
  2525.         if (!$this->homeworkBookmarks->contains($homeworkBookmark)) {
  2526.             $this->homeworkBookmarks->add($homeworkBookmark);
  2527.             $homeworkBookmark->setUser($this);
  2528.         }
  2529.         return $this;
  2530.     }
  2532.     /**
  2533.      * @return Collection<int, ScolarityHistoryEdition>
  2534.      */
  2535.     public function getScolarityHistoryEditions(): Collection
  2536.     {
  2537.         return $this->scolarityHistoryEditions;
  2538.     }
  2540.     public function addScolarityHistoryEditon(ScolarityHistoryEdition $scolarityHistoryEdition): static
  2541.     {
  2542.         if (!$this->scolarityHistoryEditions->contains($scolarityHistoryEdition)) {
  2543.             $this->scolarityHistoryEditions->add($scolarityHistoryEdition);
  2544.             $scolarityHistoryEdition->setAuthor($this);
  2545.         }
  2547.         return $this;
  2548.     }
  2551.     public function removeHomeworkBookmark(HomeworkBookmark $homeworkBookmark): static
  2552.     {
  2553.         if ($this->homeworkBookmarks->removeElement($homeworkBookmark)) {
  2554.             // set the owning side to null (unless already changed)
  2555.             if ($homeworkBookmark->getUser() === $this) {
  2556.                 $homeworkBookmark->setUser(null);
  2557.             }
  2558.             return $this;
  2559.         }
  2560.     }
  2561.     public function removeScolarityHistoryEdition(ScolarityHistoryEdition $scolarityHistoryEdition): static
  2562.     {
  2563.         if ($this->scolarityHistoryEditions->removeElement($scolarityHistoryEdition)) {
  2564.             // set the owning side to null (unless already changed)
  2565.             if ($scolarityHistoryEdition->getAuthor() === $this) {
  2566.                 $scolarityHistoryEdition->setAuthor(null);
  2567.             }
  2568.         }
  2570.         return $this;
  2571.     }
  2573.     /**
  2574.      * @return Collection<int, JustifyAbsence>
  2575.      */
  2576.     public function getJustifyAbsences(): Collection
  2577.     {
  2578.         return $this->justifyAbsences;
  2579.     }
  2581.     public function addJustifyAbsence(JustifyAbsence $justifyAbsence): static
  2582.     {
  2583.         if (!$this->justifyAbsences->contains($justifyAbsence)) {
  2584.             $this->justifyAbsences->add($justifyAbsence);
  2585.             $justifyAbsence->setAuthor($this);
  2586.         }
  2588.         return $this;
  2589.     }
  2591.     public function removeJustifyAbsence(JustifyAbsence $justifyAbsence): static
  2592.     {
  2593.         if ($this->justifyAbsences->removeElement($justifyAbsence)) {
  2594.             // set the owning side to null (unless already changed)
  2595.             if ($justifyAbsence->getAuthor() === $this) {
  2596.                 $justifyAbsence->setAuthor(null);
  2597.             }
  2598.         }
  2600.         return $this;
  2601.     }
  2603.     /**
  2604.      * @return Collection<int, VerbalProcess>
  2605.      */
  2606.     public function getVerbalProcesses(): Collection
  2607.     {
  2608.         return $this->verbalProcesses;
  2609.     }
  2611.     public function addVerbalProcess(VerbalProcess $verbalProcess): static
  2612.     {
  2613.         if (!$this->verbalProcesses->contains($verbalProcess)) {
  2614.             $this->verbalProcesses->add($verbalProcess);
  2615.             $verbalProcess->setAuthor($this);
  2616.         }
  2618.         return $this;
  2619.     }
  2621.     public function removeVerbalProcess(VerbalProcess $verbalProcess): static
  2622.     {
  2623.         if ($this->verbalProcesses->removeElement($verbalProcess)) {
  2624.             // set the owning side to null (unless already changed)
  2625.             if ($verbalProcess->getAuthor() === $this) {
  2626.                 $verbalProcess->setAuthor(null);
  2627.             }
  2628.         }
  2630.         return $this;
  2631.     }
  2633.     /**
  2634.      * @return Collection<int, AbsenceDisciplineConcileConfig>
  2635.      */
  2636.     public function getAbsenceDisciplineConcileConfigs(): Collection
  2637.     {
  2638.         return $this->absenceDisciplineConcileConfigs;
  2639.     }
  2641.     public function addAbsenceDisciplineConcileConfig(AbsenceDisciplineConcileConfig $absenceDisciplineConcileConfig): static
  2642.     {
  2643.         if (!$this->absenceDisciplineConcileConfigs->contains($absenceDisciplineConcileConfig)) {
  2644.             $this->absenceDisciplineConcileConfigs->add($absenceDisciplineConcileConfig);
  2645.             $absenceDisciplineConcileConfig->setAuthor($this);
  2646.         }
  2648.         return $this;
  2649.     }
  2651.     public function removeAbsenceDisciplineConcileConfig(AbsenceDisciplineConcileConfig $absenceDisciplineConcileConfig): static
  2652.     {
  2653.         if ($this->absenceDisciplineConcileConfigs->removeElement($absenceDisciplineConcileConfig)) {
  2654.             // set the owning side to null (unless already changed)
  2655.             if ($absenceDisciplineConcileConfig->getAuthor() === $this) {
  2656.                 $absenceDisciplineConcileConfig->setAuthor(null);
  2657.             }
  2658.         }
  2660.         return $this;
  2661.     }
  2663.     /**
  2664.      * @return Collection<int, TheClass>
  2665.      */
  2666.     public function getTheClassesTeached(): Collection
  2667.     {
  2668.         return $this->theClassesTeached;
  2669.     }
  2671.     public function addTheClassesTeached(TheClass $theClassesTeached): static
  2672.     {
  2673.         if (!$this->theClassesTeached->contains($theClassesTeached)) {
  2674.             $this->theClassesTeached->add($theClassesTeached);
  2675.             $theClassesTeached->setProf($this);
  2676.         }
  2678.         return $this;
  2679.     }
  2681.     public function removeTheClassesTeached(TheClass $theClassesTeached): static
  2682.     {
  2683.         if ($this->theClassesTeached->removeElement($theClassesTeached)) {
  2684.             // set the owning side to null (unless already changed)
  2685.             if ($theClassesTeached->getProf() === $this) {
  2686.                 $theClassesTeached->setProf(null);
  2687.             }
  2688.         }
  2690.         return $this;
  2691.     }
  2693.     /**
  2694.      * @return Collection<int, PrimaryNote>
  2695.      */
  2696.     public function getPrimaryNotes(): Collection
  2697.     {
  2698.         return $this->primaryNotes;
  2699.     }
  2701.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  2702.     {
  2703.         if (!$this->primaryNotes->contains($primaryNote)) {
  2704.             $this->primaryNotes->add($primaryNote);
  2705.             $primaryNote->setAuthor($this);
  2706.         }
  2708.         return $this;
  2709.     }
  2711.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  2712.     {
  2713.         if ($this->primaryNotes->removeElement($primaryNote)) {
  2714.             // set the owning side to null (unless already changed)
  2715.             if ($primaryNote->getAuthor() === $this) {
  2716.                 $primaryNote->setAuthor(null);
  2717.             }
  2718.         }
  2720.         return $this;
  2721.     }
  2723.     /**
  2724.      * @return Collection<int, VerbalProcessCategory>
  2725.      */
  2726.     public function getVerbalProcessCategories(): Collection
  2727.     {
  2728.         return $this->verbalProcessCategories;
  2729.     }
  2731.     public function addVerbalProcessCategory(VerbalProcessCategory $verbalProcessCategory): static
  2732.     {
  2733.         if (!$this->verbalProcessCategories->contains($verbalProcessCategory)) {
  2734.             $this->verbalProcessCategories->add($verbalProcessCategory);
  2735.             $verbalProcessCategory->setAuthor($this);
  2736.         }
  2738.         return $this;
  2739.     }
  2741.     public function removeVerbalProcessCategory(VerbalProcessCategory $verbalProcessCategory): static
  2742.     {
  2743.         if ($this->verbalProcessCategories->removeElement($verbalProcessCategory)) {
  2744.             // set the owning side to null (unless already changed)
  2745.             if ($verbalProcessCategory->getAuthor() === $this) {
  2746.                 $verbalProcessCategory->setAuthor(null);
  2747.             }
  2748.         }
  2750.         return $this;
  2751.     }
  2753.     public function getTheme(): ?string
  2754.     {
  2755.         return $this->theme;
  2756.     }
  2758.     public function setTheme(?string $theme): static
  2759.     {
  2760.         $this->theme = $theme;
  2762.         return $this;
  2763.     }
  2765.     public function getPicture(): ?string
  2766.     {
  2767.         return $this->picture;
  2768.     }
  2770.     public function setPicture(?string $picture): static
  2771.     {
  2772.         $this->picture = $picture;
  2774.         return $this;
  2775.     }
  2777.     public function getSexe(): ?string
  2778.     {
  2779.         return $this->sexe;
  2780.     }
  2782.     public function setSexe(?string $sexe): static
  2783.     {
  2784.         $this->sexe = $sexe;
  2786.         return $this;
  2787.     }
  2789.     /**
  2790.      * @return Collection<int, UserAndroidToken>
  2791.      */
  2792.     public function getUserAndroidTokens(): Collection
  2793.     {
  2794.         return $this->userAndroidTokens;
  2795.     }
  2797.     public function addUserAndroidToken(UserAndroidToken $userAndroidToken): static
  2798.     {
  2799.         if (!$this->userAndroidTokens->contains($userAndroidToken)) {
  2800.             $this->userAndroidTokens->add($userAndroidToken);
  2801.             $userAndroidToken->setUser($this);
  2802.         }
  2804.         return $this;
  2805.     }
  2807.     public function removeUserAndroidToken(UserAndroidToken $userAndroidToken): static
  2808.     {
  2809.         if ($this->userAndroidTokens->removeElement($userAndroidToken)) {
  2810.             // set the owning side to null (unless already changed)
  2811.             if ($userAndroidToken->getUser() === $this) {
  2812.                 $userAndroidToken->setUser(null);
  2813.             }
  2814.         }
  2816.         return $this;
  2817.     }
  2819.     /**
  2820.      * @return Collection<int, UserIphoneToken>
  2821.      */
  2822.     public function getUserIphoneTokens(): Collection
  2823.     {
  2824.         return $this->userIphoneTokens;
  2825.     }
  2827.     public function addUserIphoneToken(UserIphoneToken $userIphoneToken): static
  2828.     {
  2829.         if (!$this->userIphoneTokens->contains($userIphoneToken)) {
  2830.             $this->userIphoneTokens->add($userIphoneToken);
  2831.             $userIphoneToken->setUser($this);
  2832.         }
  2834.         return $this;
  2835.     }
  2837.     public function removeUserIphoneToken(UserIphoneToken $userIphoneToken): static
  2838.     {
  2839.         if ($this->userIphoneTokens->removeElement($userIphoneToken)) {
  2840.             // set the owning side to null (unless already changed)
  2841.             if ($userIphoneToken->getUser() === $this) {
  2842.                 $userIphoneToken->setUser(null);
  2843.             }
  2844.         }
  2846.         return $this;
  2847.     }
  2849.     public function getLocalPhoneLang(): ?string
  2850.     {
  2851.         return $this->localPhoneLang;
  2852.     }
  2854.     public function setLocalPhoneLang(?string $localPhoneLang): static
  2855.     {
  2856.         $this->localPhoneLang = $localPhoneLang;
  2858.         return $this;
  2859.     }
  2861.     /**
  2862.      * @return Collection<int, AbsenceBlameConfig>
  2863.      */
  2864.     public function getAbsenceBlameConfigs(): Collection
  2865.     {
  2866.         return $this->absenceBlameConfigs;
  2867.     }
  2869.     public function addAbsenceBlameConfig(AbsenceBlameConfig $absenceBlameConfig): static
  2870.     {
  2871.         if (!$this->absenceBlameConfigs->contains($absenceBlameConfig)) {
  2872.             $this->absenceBlameConfigs->add($absenceBlameConfig);
  2873.             $absenceBlameConfig->setAuthor($this);
  2874.         }
  2876.         return $this;
  2877.     }
  2879.     public function removeAbsenceBlameConfig(AbsenceBlameConfig $absenceBlameConfig): static
  2880.     {
  2881.         if ($this->absenceBlameConfigs->removeElement($absenceBlameConfig)) {
  2882.             // set the owning side to null (unless already changed)
  2883.             if ($absenceBlameConfig->getAuthor() === $this) {
  2884.                 $absenceBlameConfig->setAuthor(null);
  2885.             }
  2886.         }
  2888.         return $this;
  2889.     }
  2891.     /**
  2892.      * @return Collection<int, AbsenceWarningConfig>
  2893.      */
  2894.     public function getAbsenceWarningConfigs(): Collection
  2895.     {
  2896.         return $this->absenceWarningConfigs;
  2897.     }
  2899.     public function addAbsenceWarningConfig(AbsenceWarningConfig $absenceWarningConfig): static
  2900.     {
  2901.         if (!$this->absenceWarningConfigs->contains($absenceWarningConfig)) {
  2902.             $this->absenceWarningConfigs->add($absenceWarningConfig);
  2903.             $absenceWarningConfig->setAuthor($this);
  2904.         }
  2906.         return $this;
  2907.     }
  2909.     public function removeAbsenceWarningConfig(AbsenceWarningConfig $absenceWarningConfig): static
  2910.     {
  2911.         if ($this->absenceWarningConfigs->removeElement($absenceWarningConfig)) {
  2912.             // set the owning side to null (unless already changed)
  2913.             if ($absenceWarningConfig->getAuthor() === $this) {
  2914.                 $absenceWarningConfig->setAuthor(null);
  2915.             }
  2916.         }
  2918.         return $this;
  2919.     }
  2921.     /**
  2922.      * @return Collection<int, AbsencePunishConfig>
  2923.      */
  2924.     public function getAbsencePunishConfigs(): Collection
  2925.     {
  2926.         return $this->absencePunishConfigs;
  2927.     }
  2929.     public function addAbsencePunishConfig(AbsencePunishConfig $absencePunishConfig): static
  2930.     {
  2931.         if (!$this->absencePunishConfigs->contains($absencePunishConfig)) {
  2932.             $this->absencePunishConfigs->add($absencePunishConfig);
  2933.             $absencePunishConfig->setAuthor($this);
  2934.         }
  2936.         return $this;
  2937.     }
  2939.     public function removeAbsencePunishConfig(AbsencePunishConfig $absencePunishConfig): static
  2940.     {
  2941.         if ($this->absencePunishConfigs->removeElement($absencePunishConfig)) {
  2942.             // set the owning side to null (unless already changed)
  2943.             if ($absencePunishConfig->getAuthor() === $this) {
  2944.                 $absencePunishConfig->setAuthor(null);
  2945.             }
  2946.         }
  2948.         return $this;
  2949.     }
  2951.     /**
  2952.      * @return Collection<int, AbsenceExclusionConfig>
  2953.      */
  2954.     public function getAbsenceExclusionConfigs(): Collection
  2955.     {
  2956.         return $this->absenceExclusionConfigs;
  2957.     }
  2959.     public function addAbsenceExclusionConfig(AbsenceExclusionConfig $absenceExclusionConfig): static
  2960.     {
  2961.         if (!$this->absenceExclusionConfigs->contains($absenceExclusionConfig)) {
  2962.             $this->absenceExclusionConfigs->add($absenceExclusionConfig);
  2963.             $absenceExclusionConfig->setAuthor($this);
  2964.         }
  2966.         return $this;
  2967.     }
  2969.     public function removeAbsenceExclusionConfig(AbsenceExclusionConfig $absenceExclusionConfig): static
  2970.     {
  2971.         if ($this->absenceExclusionConfigs->removeElement($absenceExclusionConfig)) {
  2972.             // set the owning side to null (unless already changed)
  2973.             if ($absenceExclusionConfig->getAuthor() === $this) {
  2974.                 $absenceExclusionConfig->setAuthor(null);
  2975.             }
  2976.         }
  2978.         return $this;
  2979.     }
  2981.     /**
  2982.      * @return Collection<int, GlobalDisciplineEnabledConfig>
  2983.      */
  2984.     public function getGlobalDisciplineEnabledConfigs(): Collection
  2985.     {
  2986.         return $this->globalDisciplineEnabledConfigs;
  2987.     }
  2989.     public function addGlobalDisciplineEnabledConfig(GlobalDisciplineEnabledConfig $globalDisciplineEnabledConfig): static
  2990.     {
  2991.         if (!$this->globalDisciplineEnabledConfigs->contains($globalDisciplineEnabledConfig)) {
  2992.             $this->globalDisciplineEnabledConfigs->add($globalDisciplineEnabledConfig);
  2993.             $globalDisciplineEnabledConfig->setAuthor($this);
  2994.         }
  2996.         return $this;
  2997.     }
  2999.     public function removeGlobalDisciplineEnabledConfig(GlobalDisciplineEnabledConfig $globalDisciplineEnabledConfig): static
  3000.     {
  3001.         if ($this->globalDisciplineEnabledConfigs->removeElement($globalDisciplineEnabledConfig)) {
  3002.             // set the owning side to null (unless already changed)
  3003.             if ($globalDisciplineEnabledConfig->getAuthor() === $this) {
  3004.                 $globalDisciplineEnabledConfig->setAuthor(null);
  3005.             }
  3006.         }
  3008.         return $this;
  3009.     }
  3011.     /**
  3012.      * @return Collection<int, AbsenceRetainedConfig>
  3013.      */
  3014.     public function getAbsenceRetainedConfigs(): Collection
  3015.     {
  3016.         return $this->absenceRetainedConfigs;
  3017.     }
  3019.     public function addAbsenceRetainedConfig(AbsenceRetainedConfig $absenceRetainedConfig): static
  3020.     {
  3021.         if (!$this->absenceRetainedConfigs->contains($absenceRetainedConfig)) {
  3022.             $this->absenceRetainedConfigs->add($absenceRetainedConfig);
  3023.             $absenceRetainedConfig->setAuthor($this);
  3024.         }
  3026.         return $this;
  3027.     }
  3029.     public function removeAbsenceRetainedConfig(AbsenceRetainedConfig $absenceRetainedConfig): static
  3030.     {
  3031.         if ($this->absenceRetainedConfigs->removeElement($absenceRetainedConfig)) {
  3032.             // set the owning side to null (unless already changed)
  3033.             if ($absenceRetainedConfig->getAuthor() === $this) {
  3034.                 $absenceRetainedConfig->setAuthor(null);
  3035.             }
  3036.         }
  3038.         return $this;
  3039.     }
  3041.     public function getUserToken(): ?string
  3042.     {
  3043.         return $this->userToken;
  3044.     }
  3046.     public function setUserToken(?string $userToken): static
  3047.     {
  3048.         $this->userToken = $userToken;
  3050.         return $this;
  3051.     }
  3053.     /**
  3054.      * @return Collection<int, DisciplineConcile>
  3055.      */
  3056.     public function getDisciplineConciles(): Collection
  3057.     {
  3058.         return $this->disciplineConciles;
  3059.     }
  3061.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  3062.     {
  3063.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  3064.             $this->disciplineConciles->add($disciplineConcile);
  3065.             $disciplineConcile->setAuthor($this);
  3066.         }
  3068.         return $this;
  3069.     }
  3071.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  3072.     {
  3073.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  3074.             // set the owning side to null (unless already changed)
  3075.             if ($disciplineConcile->getAuthor() === $this) {
  3076.                 $disciplineConcile->setAuthor(null);
  3077.             }
  3078.         }
  3080.         return $this;
  3081.     }
  3083.     /**
  3084.      * @return Collection<int, RefreshToken>
  3085.      */
  3086.     public function getRefreshTokens(): Collection
  3087.     {
  3088.         return $this->refreshTokens;
  3089.     }
  3091.     public function addRefreshToken(RefreshToken $refreshToken): static
  3092.     {
  3093.         if (!$this->refreshTokens->contains($refreshToken)) {
  3094.             $this->refreshTokens->add($refreshToken);
  3095.             $refreshToken->setUser($this);
  3096.         }
  3098.         return $this;
  3099.     }
  3101.     public function removeRefreshToken(RefreshToken $refreshToken): static
  3102.     {
  3103.         if ($this->refreshTokens->removeElement($refreshToken)) {
  3104.             // set the owning side to null (unless already changed)
  3105.             if ($refreshToken->getUser() === $this) {
  3106.                 $refreshToken->setUser(null);
  3107.             }
  3108.         }
  3110.         return $this;
  3111.     }
  3113.     /**
  3114.      * @return Collection<int, UserNotification>
  3115.      */
  3116.     public function getUserNotifications(): Collection
  3117.     {
  3118.         return $this->userNotifications;
  3119.     }
  3121.     public function addUserNotification(UserNotification $userNotification): static
  3122.     {
  3123.         if (!$this->userNotifications->contains($userNotification)) {
  3124.             $this->userNotifications->add($userNotification);
  3125.             $userNotification->setUser($this);
  3126.         }
  3128.         return $this;
  3129.     }
  3131.     public function removeUserNotification(UserNotification $userNotification): static
  3132.     {
  3133.         if ($this->userNotifications->removeElement($userNotification)) {
  3134.             // set the owning side to null (unless already changed)
  3135.             if ($userNotification->getUser() === $this) {
  3136.                 $userNotification->setUser(null);
  3137.             }
  3138.         }
  3140.         return $this;
  3141.     }
  3143.     /**
  3144.      * @return Collection<int, DiscussionClassMessage>
  3145.      */
  3146.     public function getDiscussionClassMessagesRead(): Collection
  3147.     {
  3148.         return $this->discussionClassMessagesRead;
  3149.     }
  3151.     public function addDiscussionClassMessagesRead(DiscussionClassMessage $discussionClassMessagesRead): static
  3152.     {
  3153.         if (!$this->discussionClassMessagesRead->contains($discussionClassMessagesRead)) {
  3154.             $this->discussionClassMessagesRead->add($discussionClassMessagesRead);
  3155.             $discussionClassMessagesRead->addReader($this);
  3156.         }
  3158.         return $this;
  3159.     }
  3161.     public function removeDiscussionClassMessagesRead(DiscussionClassMessage $discussionClassMessagesRead): static
  3162.     {
  3163.         if ($this->discussionClassMessagesRead->removeElement($discussionClassMessagesRead)) {
  3164.             $discussionClassMessagesRead->removeReader($this);
  3165.         }
  3167.         return $this;
  3168.     }
  3170.     /**
  3171.      * @return Collection<int, AgendaTimeConvertion>
  3172.      */
  3173.     public function getAgendaTimeConvertions(): Collection
  3174.     {
  3175.         return $this->agendaTimeConvertions;
  3176.     }
  3178.     public function addAgendaTimeConvertion(AgendaTimeConvertion $agendaTimeConvertion): static
  3179.     {
  3180.         if (!$this->agendaTimeConvertions->contains($agendaTimeConvertion)) {
  3181.             $this->agendaTimeConvertions->add($agendaTimeConvertion);
  3182.             $agendaTimeConvertion->setAuthor($this);
  3183.         }
  3185.         return $this;
  3186.     }
  3188.     public function removeAgendaTimeConvertion(AgendaTimeConvertion $agendaTimeConvertion): static
  3189.     {
  3190.         if ($this->agendaTimeConvertions->removeElement($agendaTimeConvertion)) {
  3191.             // set the owning side to null (unless already changed)
  3192.             if ($agendaTimeConvertion->getAuthor() === $this) {
  3193.                 $agendaTimeConvertion->setAuthor(null);
  3194.             }
  3195.         }
  3197.         return $this;
  3198.     }
  3200.     /**
  3201.      * @return Collection<int, Competence>
  3202.      */
  3203.     public function getCompetences(): Collection
  3204.     {
  3205.         return $this->competences;
  3206.     }
  3208.     public function addCompetence(Competence $competence): static
  3209.     {
  3210.         if (!$this->competences->contains($competence)) {
  3211.             $this->competences->add($competence);
  3212.             $competence->setAuthor($this);
  3213.         }
  3215.         return $this;
  3216.     }
  3218.     public function removeCompetence(Competence $competence): static
  3219.     {
  3220.         if ($this->competences->removeElement($competence)) {
  3221.             // set the owning side to null (unless already changed)
  3222.             if ($competence->getAuthor() === $this) {
  3223.                 $competence->setAuthor(null);
  3224.             }
  3225.         }
  3227.         return $this;
  3228.     }
  3230.     /**
  3231.      * @return Collection<int, ProfTime>
  3232.      */
  3233.     public function getProfTimes(): Collection
  3234.     {
  3235.         return $this->profTimes;
  3236.     }
  3238.     public function addProfTime(ProfTime $profTime): static
  3239.     {
  3240.         if (!$this->profTimes->contains($profTime)) {
  3241.             $this->profTimes->add($profTime);
  3242.             $profTime->setProf($this);
  3243.         }
  3245.         return $this;
  3246.     }
  3248.     public function removeProfTime(ProfTime $profTime): static
  3249.     {
  3250.         if ($this->profTimes->removeElement($profTime)) {
  3251.             // set the owning side to null (unless already changed)
  3252.             if ($profTime->getProf() === $this) {
  3253.                 $profTime->setProf(null);
  3254.             }
  3255.         }
  3257.         return $this;
  3258.     }
  3260.     /**
  3261.      * @return Collection<int, GlobalSchoolBreak>
  3262.      */
  3263.     public function getGlobalSchoolBreaks(): Collection
  3264.     {
  3265.         return $this->globalSchoolBreaks;
  3266.     }
  3268.     public function addGlobalSchoolBreak(GlobalSchoolBreak $globalSchoolBreak): static
  3269.     {
  3270.         if (!$this->globalSchoolBreaks->contains($globalSchoolBreak)) {
  3271.             $this->globalSchoolBreaks->add($globalSchoolBreak);
  3272.             $globalSchoolBreak->setAuthor($this);
  3273.         }
  3275.         return $this;
  3276.     }
  3278.     public function removeGlobalSchoolBreak(GlobalSchoolBreak $globalSchoolBreak): static
  3279.     {
  3280.         if ($this->globalSchoolBreaks->removeElement($globalSchoolBreak)) {
  3281.             // set the owning side to null (unless already changed)
  3282.             if ($globalSchoolBreak->getAuthor() === $this) {
  3283.                 $globalSchoolBreak->setAuthor(null);
  3284.             }
  3285.         }
  3287.         return $this;
  3288.     }
  3290.     /**
  3291.      * @return Collection<int, TeacherAbsence>
  3292.      */
  3293.     public function getTeacherAbsences(): Collection
  3294.     {
  3295.         return $this->teacherAbsences;
  3296.     }
  3298.     public function addTeacherAbsence(TeacherAbsence $teacherAbsence): static
  3299.     {
  3300.         if (!$this->teacherAbsences->contains($teacherAbsence)) {
  3301.             $this->teacherAbsences->add($teacherAbsence);
  3302.             $teacherAbsence->setTeacher($this);
  3303.         }
  3305.         return $this;
  3306.     }
  3308.     public function removeTeacherAbsence(TeacherAbsence $teacherAbsence): static
  3309.     {
  3310.         if ($this->teacherAbsences->removeElement($teacherAbsence)) {
  3311.             // set the owning side to null (unless already changed)
  3312.             if ($teacherAbsence->getTeacher() === $this) {
  3313.                 $teacherAbsence->setTeacher(null);
  3314.             }
  3315.         }
  3317.         return $this;
  3318.     }
  3320.     /**
  3321.      * @return Collection<int, TeacherActivity>
  3322.      */
  3323.     public function getTeacherActivities(): Collection
  3324.     {
  3325.         return $this->teacherActivities;
  3326.     }
  3328.     public function addTeacherActivity(TeacherActivity $teacherActivity): static
  3329.     {
  3330.         if (!$this->teacherActivities->contains($teacherActivity)) {
  3331.             $this->teacherActivities->add($teacherActivity);
  3332.             $teacherActivity->setTeacher($this);
  3333.         }
  3335.         return $this;
  3336.     }
  3338.     public function removeTeacherActivity(TeacherActivity $teacherActivity): static
  3339.     {
  3340.         if ($this->teacherActivities->removeElement($teacherActivity)) {
  3341.             // set the owning side to null (unless already changed)
  3342.             if ($teacherActivity->getTeacher() === $this) {
  3343.                 $teacherActivity->setTeacher(null);
  3344.             }
  3345.         }
  3347.         return $this;
  3348.     }
  3350.     public function getRegionInspect(): ?Region
  3351.     {
  3352.         return $this->regionInspect;
  3353.     }
  3355.     public function setRegionInspect(?Region $regionInspect): static
  3356.     {
  3357.         $this->regionInspect = $regionInspect;
  3359.         return $this;
  3360.     }
  3362.     public function getDepartmentInspect(): ?Department
  3363.     {
  3364.         return $this->departmentInspect;
  3365.     }
  3367.     public function setDepartmentInspect(?Department $departmentInspect): static
  3368.     {
  3369.         $this->departmentInspect = $departmentInspect;
  3371.         return $this;
  3372.     }
  3374.     public function getDevices(): Collection
  3375.     { 
  3376.         return $this->devices;
  3377.     }
  3379.     public function addDevice(UserDevice $device): static
  3380.     {
  3381.         if (!$this->devices->contains($device)) {
  3382.             $this->devices->add($device);
  3383.             $device->setUser($this);
  3384.         }
  3385.         return $this;
  3386.     }
  3387. }