Symfony Profiler

<?php
namespace App\Entity;
use App\Repository\UserRepository;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
use Symfony\Component\Security\Core\User\UserInterface;
use App\Entity\Traits\Timestampable;
use JMS\Serializer\Annotation\Groups;
#[ORM\HasLifecycleCallbacks]
#[ORM\Entity(repositoryClass: UserRepository::class)]
#[ORM\Table(name: '`user`')]
#[UniqueEntity(fields: ['phone'], message: 'There is already an account with this email')]
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
use Timestampable;
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
#[Groups(['chatWebNew', 'chatView', 'chatAllList', 'singleMessage','getDiscussion','getStudents','getSubject','getAppUsers', 'getDiscussionMessage','getDiscussionClassMessage'])]
private ?int $id = null;
#[ORM\Column(length: 180, nullable: true)]
#[Groups(["getAppUsers"])]
private ?string $email = null;
#[ORM\Column]
private array $roles = [];
/**
* @var string The hashed password
*/
#[ORM\Column]
private ?string $password = null;
#[ORM\Column(length: 255, nullable: true)]
#[Groups(['chatWebNew', 'chatAllList','getDiscussion','getAppUsers', 'getDiscussionMessage','getDiscussionClassMessage'])]
private ?string $firstName = null;
#[ORM\Column(length: 255, nullable: true)]
#[Groups(['chatWebNew', 'chatAllList','getDiscussion','getAppUsers', 'getDiscussionMessage', 'getDiscussionClassMessage'])]
private ?string $lastName = null;
#[ORM\Column(length: 255)]
#[Groups(['getAppUsers'])]
private ?string $phone = null;
#[ORM\Column(length: 255)]
#[Groups(['chatWebNew','getDiscussion','getAppUsers', 'getDiscussionMessage', 'getDiscussionClassMessage'])]
private ?string $userType = null;
#[ORM\Column(type: 'boolean')]
private $isVerified = false;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: News::class)]
private Collection $news;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Event::class)]
private Collection $events;
#[ORM\OneToMany(mappedBy: 'user', targetEntity: UserYear::class)]
private Collection $userYears;
#[ORM\Column(length: 255, nullable: true)]
#[Groups(['getAppUsers'])]
private ?string $matricule = null;
#[ORM\OneToMany(mappedBy: 'prof', targetEntity: Subject::class)]
private Collection $subjects;
#[ORM\OneToMany(mappedBy: 'parent', targetEntity: Student::class)]
private Collection $students;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: HomeWork::class)]
private Collection $homeWorks;
#[ORM\OneToMany(mappedBy: 'initiator', targetEntity: Chat::class)]
private Collection $chats;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Message::class)]
private Collection $messages;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: DocInfo::class)]
private Collection $docInfos;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: DocInfo::class)]
private Collection $docInfoUpdated;
#[ORM\OneToMany(mappedBy: 'parent', targetEntity: DocInfo::class)]
private Collection $parentDocInfos;
#[ORM\OneToMany(mappedBy: 'userA', targetEntity: Discussion::class)]
private Collection $discussions;
#[ORM\OneToMany(mappedBy: 'messageBy', targetEntity: DiscussionMessage::class)]
private Collection $discussionMessages;
#[ORM\OneToMany(mappedBy: 'user', targetEntity: Notifications::class)]
private Collection $notifications;
#[ORM\Column(length: 255, nullable: true)]
private ?string $fullName = null;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Absence::class)]
private Collection $absences;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: Absence::class)]
private Collection $absencesEdited;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: CategoryEvent::class)]
private Collection $categoryEvents;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: CategoryEvent::class)]
private Collection $categoryEventsEdited;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: ClassYear::class)]
private Collection $classYears;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: ClassYear::class)]
private Collection $ClassYearsEdited;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: Event::class)]
private Collection $eventsEdited;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Exams::class)]
private Collection $exams;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: Exams::class)]
private Collection $examsEdited;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: HomeWork::class)]
private Collection $homeworksEdited;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Late::class)]
private Collection $lates;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: Late::class)]
private Collection $latesEdited;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: NewsCategory::class)]
private Collection $newsCategories;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: NewsCategory::class)]
private Collection $newsCategoriesEdited;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Note::class)]
private Collection $notes;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: Note::class)]
private Collection $notesEdited;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: SchoolSection::class)]
private Collection $schoolSections;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: SchoolSection::class)]
private Collection $schoolSectionsEdited;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: SchoolYear::class)]
private Collection $schoolYears;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: SchoolYear::class)]
private Collection $schoolYearsEdited;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: Student::class)]
private Collection $studentsEdited;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: Subject::class)]
private Collection $subjectsEdited;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: SubjectGroup::class)]
private Collection $subjectGroups;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: SubjectGroup::class)]
private Collection $subjectGroupsEdited;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: TheClass::class)]
private Collection $theClasses;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: TheClass::class)]
private Collection $theClassesEdited;
#[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'users', cascade: ["persist"])]
private ?self $author = null;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: self::class)]
private Collection $users;
#[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'usersEdited', cascade: ["persist"])]
private ?self $editor = null;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: self::class)]
private Collection $usersEdited;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Student::class)]
private Collection $studentsCreated;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Subject::class)]
private Collection $subjectsCreated;
#[ORM\OneToMany(mappedBy: 'editor', targetEntity: News::class)]
private Collection $newsEdited;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Punish::class)]
private Collection $punishes;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: PunishCategory::class)]
private Collection $punishCategories;
#[Groups(['getDiscussion'])]
#[ORM\Column(type: Types::BIGINT, nullable: true)]
private ?string $lastRequestTs = null;
#[ORM\ManyToOne(inversedBy: 'users', cascade: ["persist"])]
private ?School $school = null;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: DiscussionClassMessage::class)]
private Collection $discussionClassMessages;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Agenda::class)]
private Collection $agendas;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: ExamAgenda::class)]
private Collection $examAgendas;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: SubSequence::class)]
private Collection $subSequences;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Quarter::class)]
private Collection $quarters;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: SubNote::class)]
private Collection $subNotes;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: AgendaDay::class)]
private Collection $agendaDays;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: AgendaElement::class)]
private Collection $agendaElements;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: ExamAgendaDay::class)]
private Collection $examAgendaDays;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: ExamAgendaElement::class)]
private Collection $examAgendaElements;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Appreciation::class)]
private Collection $appreciations;
#[ORM\OneToMany(mappedBy: 'user', targetEntity: LocalAccount::class)]
private Collection $localAccounts;
#[ORM\OneToMany(mappedBy: 'user', targetEntity: NewsBookmark::class)]
private Collection $newsBookmarks;
#[ORM\OneToMany(mappedBy: 'user', targetEntity: HomeworkBookmark::class)]
private Collection $homeworkBookmarks;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: ScolarityHistory::class)]
private Collection $scolarityHistories;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: ScolarityHistoryEdition::class)]
private Collection $scolarityHistoryEditions;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: JustifyAbsence::class)]
private Collection $justifyAbsences;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: VerbalProcess::class)]
private Collection $verbalProcesses;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceDisciplineConcileConfig::class)]
private Collection $absenceDisciplineConcileConfigs;
#[ORM\OneToMany(mappedBy: 'prof', targetEntity: TheClass::class)]
private Collection $theClassesTeached;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: PrimaryNote::class)]
private Collection $primaryNotes;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: VerbalProcessCategory::class)]
private Collection $verbalProcessCategories;
#[ORM\Column(length: 255, nullable: true)]
private ?string $theme = null;
#[ORM\Column(length: 255, nullable: true)]
private ?string $picture = null;
#[ORM\Column(length: 255, nullable: true)]
private ?string $sexe = null;
#[ORM\OneToMany(mappedBy: 'user', targetEntity: UserAndroidToken::class)]
private Collection $userAndroidTokens;
#[ORM\OneToMany(mappedBy: 'user', targetEntity: UserIphoneToken::class)]
private Collection $userIphoneTokens;
#[ORM\Column(length: 255, nullable: true)]
private ?string $localPhoneLang = null;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceBlameConfig::class)]
private Collection $absenceBlameConfigs;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceWarningConfig::class)]
private Collection $absenceWarningConfigs;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsencePunishConfig::class)]
private Collection $absencePunishConfigs;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceExclusionConfig::class)]
private Collection $absenceExclusionConfigs;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: GlobalDisciplineEnabledConfig::class)]
private Collection $globalDisciplineEnabledConfigs;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: AbsenceRetainedConfig::class)]
private Collection $absenceRetainedConfigs;
#[ORM\Column(length: 255, nullable: true)]
private ?string $userToken = null;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: DisciplineConcile::class)]
private Collection $disciplineConciles;
#[ORM\OneToMany(mappedBy: 'user', targetEntity: RefreshToken::class, orphanRemoval: true)]
private Collection $refreshTokens;
#[ORM\OneToMany(mappedBy: 'user', targetEntity: UserNotification::class)]
private Collection $userNotifications;
#[ORM\ManyToMany(targetEntity: DiscussionClassMessage::class, mappedBy: 'readers')]
private Collection $discussionClassMessagesRead;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: AgendaTimeConvertion::class)]
private Collection $agendaTimeConvertions;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: Competence::class)]
private Collection $competences;
#[ORM\OneToMany(mappedBy: 'prof', targetEntity: ProfTime::class)]
private Collection $profTimes;
#[ORM\OneToMany(mappedBy: 'author', targetEntity: GlobalSchoolBreak::class)]
private Collection $globalSchoolBreaks;
#[ORM\OneToMany(mappedBy: 'teacher', targetEntity: TeacherAbsence::class)]
private Collection $teacherAbsences;
#[ORM\OneToMany(mappedBy: 'teacher', targetEntity: TeacherActivity::class, orphanRemoval: true)]
private Collection $teacherActivities;
#[ORM\ManyToOne(inversedBy: 'users')]
private ?Region $regionInspect = null;
#[ORM\ManyToOne(inversedBy: 'users')]
private ?Department $departmentInspect = null;
public function __toString(): string
{
return $this->getFullName();
}
public function __construct()
{
$this->news = new ArrayCollection();
$this->events = new ArrayCollection();
$this->userYears = new ArrayCollection();
$this->subjects = new ArrayCollection();
$this->students = new ArrayCollection();
$this->homeWorks = new ArrayCollection();
$this->chats = new ArrayCollection();
$this->messages = new ArrayCollection();
$this->docInfos = new ArrayCollection();
$this->docInfoUpdated = new ArrayCollection();
$this->parentDocInfos = new ArrayCollection();
$this->discussions = new ArrayCollection();
$this->discussionMessages = new ArrayCollection();
$this->notifications = new ArrayCollection();
$this->absences = new ArrayCollection();
$this->absencesEdited = new ArrayCollection();
$this->categoryEvents = new ArrayCollection();
$this->categoryEventsEdited = new ArrayCollection();
$this->classYears = new ArrayCollection();
$this->ClassYearsEdited = new ArrayCollection();
$this->eventsEdited = new ArrayCollection();
$this->exams = new ArrayCollection();
$this->examsEdited = new ArrayCollection();
$this->homeworksEdited = new ArrayCollection();
$this->lates = new ArrayCollection();
$this->latesEdited = new ArrayCollection();
$this->newsCategories = new ArrayCollection();
$this->newsCategoriesEdited = new ArrayCollection();
$this->notes = new ArrayCollection();
$this->notesEdited = new ArrayCollection();
$this->schoolSections = new ArrayCollection();
$this->schoolSectionsEdited = new ArrayCollection();
$this->schoolYears = new ArrayCollection();
$this->schoolYearsEdited = new ArrayCollection();
$this->studentsEdited = new ArrayCollection();
$this->subjectsEdited = new ArrayCollection();
$this->subjectGroups = new ArrayCollection();
$this->subjectGroupsEdited = new ArrayCollection();
$this->theClasses = new ArrayCollection();
$this->theClassesEdited = new ArrayCollection();
$this->users = new ArrayCollection();
$this->usersEdited = new ArrayCollection();
$this->studentsCreated = new ArrayCollection();
$this->subjectsCreated = new ArrayCollection();
$this->newsEdited = new ArrayCollection();
$this->punishes = new ArrayCollection();
$this->punishCategories = new ArrayCollection();
$this->discussionClassMessages = new ArrayCollection();
$this->agendas = new ArrayCollection();
$this->examAgendas = new ArrayCollection();
$this->subSequences = new ArrayCollection();
$this->quarters = new ArrayCollection();
$this->subNotes = new ArrayCollection();
$this->agendaDays = new ArrayCollection();
$this->agendaElements = new ArrayCollection();
$this->examAgendaDays = new ArrayCollection();
$this->examAgendaElements = new ArrayCollection();
$this->appreciations = new ArrayCollection();
$this->localAccounts = new ArrayCollection();
$this->scolarityHistories = new ArrayCollection();
$this->scolarityHistoryEditions = new ArrayCollection();
$this->justifyAbsences = new ArrayCollection();
$this->verbalProcesses = new ArrayCollection();
$this->absenceDisciplineConcileConfigs = new ArrayCollection();
$this->theClassesTeached = new ArrayCollection();
$this->primaryNotes = new ArrayCollection();
$this->verbalProcessCategories = new ArrayCollection();
$this->newsBookmarks = new ArrayCollection();
$this->homeworkBookmarks = new ArrayCollection();
$this->userAndroidTokens = new ArrayCollection();
$this->userIphoneTokens = new ArrayCollection();
$this->absenceBlameConfigs = new ArrayCollection();
$this->absenceWarningConfigs = new ArrayCollection();
$this->absencePunishConfigs = new ArrayCollection();
$this->absenceExclusionConfigs = new ArrayCollection();
$this->globalDisciplineEnabledConfigs = new ArrayCollection();
$this->absenceRetainedConfigs = new ArrayCollection();
$this->disciplineConciles = new ArrayCollection();
$this->refreshTokens = new ArrayCollection();
$this->userNotifications = new ArrayCollection();
$this->discussionClassMessagesRead = new ArrayCollection();
$this->agendaTimeConvertions = new ArrayCollection();
$this->competences = new ArrayCollection();
$this->profTimes = new ArrayCollection();
$this->globalSchoolBreaks = new ArrayCollection();
$this->teacherAbsences = new ArrayCollection();
$this->teacherActivities = new ArrayCollection();
}
public function getFullName():string
{
return $this->getLastName()." ".$this->getFirstName();
}
public function getId(): ?int
{
return $this->id;
}
public function getEmail(): ?string
{
return $this->email;
}
public function setEmail(string $email): static
{
$this->email = $email;
return $this;
}
/**
* A visual identifier that represents this user.
*
* @see UserInterface
*/
public function getUserIdentifier(): string
{
return (string) $this->email;
}
/**
* @see UserInterface
*/
public function getRoles(): array
{
$roles = $this->roles;
// guarantee every user at least has ROLE_USER
$roles[] = 'ROLE_USER';
return array_unique($roles);
}
public function setRoles(array $roles): static
{
$this->roles = $roles;
return $this;
}
/**
* @see PasswordAuthenticatedUserInterface
*/
public function getPassword(): string
{
return $this->password;
}
public function setPassword(string $password): static
{
$this->password = $password;
return $this;
}
/**
* @see UserInterface
*/
public function eraseCredentials(): void
{
// If you store any temporary, sensitive data on the user, clear it here
// $this->plainPassword = null;
}
public function getFirstName(): ?string
{
return $this->firstName;
}
public function setFirstName(string $firstName): static
{
$this->firstName = $firstName;
return $this;
}
public function getLastName(): ?string
{
return $this->lastName;
}
public function setLastName(string $lastName): static
{
$this->lastName = $lastName;
return $this;
}
public function getPhone(): ?string
{
return $this->phone;
}
public function setPhone(string $phone): static
{
$this->phone = $phone;
return $this;
}
public function getUserType(): ?string
{
return $this->userType;
}
public function setUserType(string $userType): static
{
$this->userType = $userType;
return $this;
}
public function isVerified(): bool
{
return $this->isVerified;
}
public function setIsVerified(bool $isVerified): static
{
$this->isVerified = $isVerified;
return $this;
}
/**
* @return Collection<int, News>
*/
public function getNews(): Collection
{
return $this->news;
}
public function addNews(News $news): static
{
if (!$this->news->contains($news)) {
$this->news->add($news);
$news->setAuthor($this);
}
return $this;
}
public function removeNews(News $news): static
{
if ($this->news->removeElement($news)) {
// set the owning side to null (unless already changed)
if ($news->getAuthor() === $this) {
$news->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, Event>
*/
public function getEvents(): Collection
{
return $this->events;
}
public function addEvent(Event $event): static
{
if (!$this->events->contains($event)) {
$this->events->add($event);
$event->setAuthor($this);
}
return $this;
}
public function removeEvent(Event $event): static
{
if ($this->events->removeElement($event)) {
// set the owning side to null (unless already changed)
if ($event->getAuthor() === $this) {
$event->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, UserYear>
*/
public function getUserYears(): Collection
{
return $this->userYears;
}
public function addUserYear(UserYear $userYear): static
{
if (!$this->userYears->contains($userYear)) {
$this->userYears->add($userYear);
$userYear->setUser($this);
}
return $this;
}
public function removeUserYear(UserYear $userYear): static
{
if ($this->userYears->removeElement($userYear)) {
// set the owning side to null (unless already changed)
if ($userYear->getUser() === $this) {
$userYear->setUser(null);
}
}
return $this;
}
public function getMatricule(): ?string
{
return $this->matricule;
}
public function setMatricule(?string $matricule): static
{
$this->matricule = $matricule;
return $this;
}
/**
* @return Collection<int, Subject>
*/
public function getSubjects(): Collection
{
return $this->subjects;
}
public function addSubject(Subject $subject): static
{
if (!$this->subjects->contains($subject)) {
$this->subjects->add($subject);
$subject->setProf($this);
}
return $this;
}
public function removeSubject(Subject $subject): static
{
if ($this->subjects->removeElement($subject)) {
// set the owning side to null (unless already changed)
if ($subject->getProf() === $this) {
$subject->setProf(null);
}
}
return $this;
}
/**
* @return Collection<int, Student>
*/
public function getStudents(): Collection
{
return $this->students;
}
public function addStudent(Student $student): static
{
if (!$this->students->contains($student)) {
$this->students->add($student);
$student->setParent($this);
}
return $this;
}
public function removeStudent(Student $student): static
{
if ($this->students->removeElement($student)) {
// set the owning side to null (unless already changed)
if ($student->getParent() === $this) {
$student->setParent(null);
}
}
return $this;
}
/**
* @return Collection<int, HomeWork>
*/
public function getHomeWorks(): Collection
{
return $this->homeWorks;
}
public function addHomeWork(HomeWork $homeWork): static
{
if (!$this->homeWorks->contains($homeWork)) {
$this->homeWorks->add($homeWork);
$homeWork->setAuthor($this);
}
return $this;
}
public function removeHomeWork(HomeWork $homeWork): static
{
if ($this->homeWorks->removeElement($homeWork)) {
// set the owning side to null (unless already changed)
if ($homeWork->getAuthor() === $this) {
$homeWork->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, Chat>
*/
public function getChats(): Collection
{
return $this->chats;
}
public function addChat(Chat $chat): static
{
if (!$this->chats->contains($chat)) {
$this->chats->add($chat);
$chat->setInitiator($this);
}
return $this;
}
public function removeChat(Chat $chat): static
{
if ($this->chats->removeElement($chat)) {
// set the owning side to null (unless already changed)
if ($chat->getInitiator() === $this) {
$chat->setInitiator(null);
}
}
return $this;
}
/**
* @return Collection<int, Message>
*/
public function getMessages(): Collection
{
return $this->messages;
}
public function addMessage(Message $message): static
{
if (!$this->messages->contains($message)) {
$this->messages->add($message);
$message->setAuthor($this);
}
return $this;
}
public function removeMessage(Message $message): static
{
if ($this->messages->removeElement($message)) {
// set the owning side to null (unless already changed)
if ($message->getAuthor() === $this) {
$message->setAuthor(null);
}
}
return $this;
}
/* @return Collection<int, Discussion>
*/
public function getDiscussions(): Collection
{
return $this->discussions;
}
public function addDiscussion(Discussion $discussion): static
{
if (!$this->discussions->contains($discussion)) {
$this->discussions->add($discussion);
$discussion->setUserA($this);
}
return $this;
}
public function removeDiscussion(Discussion $discussion): static
{
if ($this->discussions->removeElement($discussion)) {
// set the owning side to null (unless already changed)
if ($discussion->getUserA() === $this) {
$discussion->setUserA(null);
}
}
return $this;
}
/**
* @return Collection<int, DocInfo>
*/
public function getDocInfos(): Collection
{
return $this->docInfos;
}
public function addDocInfo(DocInfo $docInfo): static
{
if (!$this->docInfos->contains($docInfo)) {
$this->docInfos->add($docInfo);
$docInfo->setAuthor($this);
}
return $this;
}
public function removeDocInfo(DocInfo $docInfo): static
{
if ($this->docInfos->removeElement($docInfo)) {
// set the owning side to null (unless already changed)
if ($docInfo->getAuthor() === $this) {
$docInfo->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, DocInfo>
*/
public function getDocInfoUpdated(): Collection
{
return $this->docInfoUpdated;
}
public function addDocInfoUpdated(DocInfo $docInfoUpdated): static
{
if (!$this->docInfoUpdated->contains($docInfoUpdated)) {
$this->docInfoUpdated->add($docInfoUpdated);
$docInfoUpdated->setEditor($this);
}
return $this;
}
public function removeDocInfoUpdated(DocInfo $docInfoUpdated): static
{
if ($this->docInfoUpdated->removeElement($docInfoUpdated)) {
// set the owning side to null (unless already changed)
if ($docInfoUpdated->getEditor() === $this) {
$docInfoUpdated->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, DocInfo>
*/
public function getParentDocInfos(): Collection
{
return $this->parentDocInfos;
}
public function addParentDocInfo(DocInfo $parentDocInfo): static
{
if (!$this->parentDocInfos->contains($parentDocInfo)) {
$this->parentDocInfos->add($parentDocInfo);
$parentDocInfo->setParent($this);
}
return $this;
}
public function removeParentDocInfo(DocInfo $parentDocInfo): static
{
if ($this->parentDocInfos->removeElement($parentDocInfo)) {
// set the owning side to null (unless already changed)
if ($parentDocInfo->getParent() === $this) {
$parentDocInfo->setParent(null);
}
}
return $this;
}
/* @return Collection<int, DiscussionMessage>
*/
public function getDiscussionMessages(): Collection
{
return $this->discussionMessages;
}
public function addDiscussionMessage(DiscussionMessage $discussionMessage): static
{
if (!$this->discussionMessages->contains($discussionMessage)) {
$this->discussionMessages->add($discussionMessage);
$discussionMessage->setMessageBy($this);
}
return $this;
}
public function removeDiscussionMessage(DiscussionMessage $discussionMessage): static
{
if ($this->discussionMessages->removeElement($discussionMessage)) {
// set the owning side to null (unless already changed)
if ($discussionMessage->getMessageBy() === $this) {
$discussionMessage->setMessageBy(null);
}
}
return $this;
}
/* @return Collection<int, Notifications>
*/
public function getNotifications(): Collection
{
return $this->notifications;
}
public function addNotification(Notifications $notification): static
{
if (!$this->notifications->contains($notification)) {
$this->notifications->add($notification);
$notification->setUser($this);
}
return $this;
}
public function removeNotification(Notifications $notification): static
{
if ($this->notifications->removeElement($notification)) {
// set the owning side to null (unless already changed)
if ($notification->getUser() === $this) {
$notification->setUser(null);
}
}
return $this;
}
public function setFullName(?string $fullName): static
{
$this->fullName = $fullName;
return $this;
}
/**
* @return Collection<int, Absence>
*/
public function getAbsences(): Collection
{
return $this->absences;
}
public function addAbsence(Absence $absence): static
{
if (!$this->absences->contains($absence)) {
$this->absences->add($absence);
$absence->setAuthor($this);
}
return $this;
}
/* @return Collection<int, Punish>
*/
public function getPunishes(): Collection
{
return $this->punishes;
}
public function addPunish(Punish $punish): static
{
if (!$this->punishes->contains($punish)) {
$this->punishes->add($punish);
$punish->setAuthor($this);
}
return $this;
}
public function removePunish(Punish $punish): static
{
if ($this->punishes->removeElement($punish)) {
// set the owning side to null (unless already changed)
if ($punish->getAuthor() === $this) {
$punish->setAuthor(null);
}
}
return $this;
}
public function removeAbsence(Absence $absence): static
{
if ($this->absences->removeElement($absence)) {
// set the owning side to null (unless already changed)
if ($absence->getAuthor() === $this) {
$absence->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, Absence>
*/
public function getAbsencesEdited(): Collection
{
return $this->absencesEdited;
}
public function addAbsencesEdited(Absence $absencesEdited): static
{
if (!$this->absencesEdited->contains($absencesEdited)) {
$this->absencesEdited->add($absencesEdited);
$absencesEdited->setEditor($this);
}
return $this;
}
public function removeAbsencesEdited(Absence $absencesEdited): static
{
if ($this->absencesEdited->removeElement($absencesEdited)) {
// set the owning side to null (unless already changed)
if ($absencesEdited->getEditor() === $this) {
$absencesEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, CategoryEvent>
*/
public function getCategoryEvents(): Collection
{
return $this->categoryEvents;
}
public function addCategoryEvent(CategoryEvent $categoryEvent): static
{
if (!$this->categoryEvents->contains($categoryEvent)) {
$this->categoryEvents->add($categoryEvent);
$categoryEvent->setAuthor($this);
}
return $this;
}
public function removeCategoryEvent(CategoryEvent $categoryEvent): static
{
if ($this->categoryEvents->removeElement($categoryEvent)) {
// set the owning side to null (unless already changed)
if ($categoryEvent->getAuthor() === $this) {
$categoryEvent->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, CategoryEvent>
*/
public function getCategoryEventsEdited(): Collection
{
return $this->categoryEventsEdited;
}
public function addCategoryEventsEdited(CategoryEvent $categoryEventsEdited): static
{
if (!$this->categoryEventsEdited->contains($categoryEventsEdited)) {
$this->categoryEventsEdited->add($categoryEventsEdited);
$categoryEventsEdited->setEditor($this);
}
return $this;
}
public function removeCategoryEventsEdited(CategoryEvent $categoryEventsEdited): static
{
if ($this->categoryEventsEdited->removeElement($categoryEventsEdited)) {
// set the owning side to null (unless already changed)
if ($categoryEventsEdited->getEditor() === $this) {
$categoryEventsEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, ClassYear>
*/
public function getClassYears(): Collection
{
return $this->classYears;
}
public function addClassYear(ClassYear $classYear): static
{
if (!$this->classYears->contains($classYear)) {
$this->classYears->add($classYear);
$classYear->setAuthor($this);
}
return $this;
}
public function removeClassYear(ClassYear $classYear): static
{
if ($this->classYears->removeElement($classYear)) {
// set the owning side to null (unless already changed)
if ($classYear->getAuthor() === $this) {
$classYear->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, ClassYear>
*/
public function getClassYearsEdited(): Collection
{
return $this->ClassYearsEdited;
}
public function addClassYearsEdited(ClassYear $classYearsEdited): static
{
if (!$this->ClassYearsEdited->contains($classYearsEdited)) {
$this->ClassYearsEdited->add($classYearsEdited);
$classYearsEdited->setEditor($this);
}
return $this;
}
public function removeClassYearsEdited(ClassYear $classYearsEdited): static
{
if ($this->ClassYearsEdited->removeElement($classYearsEdited)) {
// set the owning side to null (unless already changed)
if ($classYearsEdited->getEditor() === $this) {
$classYearsEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, Event>
*/
public function getEventsEdited(): Collection
{
return $this->eventsEdited;
}
public function addEventsEdited(Event $eventsEdited): static
{
if (!$this->eventsEdited->contains($eventsEdited)) {
$this->eventsEdited->add($eventsEdited);
$eventsEdited->setEditor($this);
}
return $this;
}
public function removeEventsEdited(Event $eventsEdited): static
{
if ($this->eventsEdited->removeElement($eventsEdited)) {
// set the owning side to null (unless already changed)
if ($eventsEdited->getEditor() === $this) {
$eventsEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, Exams>
*/
public function getExams(): Collection
{
return $this->exams;
}
public function addExam(Exams $exam): static
{
if (!$this->exams->contains($exam)) {
$this->exams->add($exam);
$exam->setAuthor($this);
}
return $this;
}
public function removeExam(Exams $exam): static
{
if ($this->exams->removeElement($exam)) {
// set the owning side to null (unless already changed)
if ($exam->getAuthor() === $this) {
$exam->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, Exams>
*/
public function getExamsEdited(): Collection
{
return $this->examsEdited;
}
public function addExamsEdited(Exams $examsEdited): static
{
if (!$this->examsEdited->contains($examsEdited)) {
$this->examsEdited->add($examsEdited);
$examsEdited->setEditor($this);
}
return $this;
}
public function removeExamsEdited(Exams $examsEdited): static
{
if ($this->examsEdited->removeElement($examsEdited)) {
// set the owning side to null (unless already changed)
if ($examsEdited->getEditor() === $this) {
$examsEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, HomeWork>
*/
public function getHomeworksEdited(): Collection
{
return $this->homeworksEdited;
}
public function addHomeworksEdited(HomeWork $homeworksEdited): static
{
if (!$this->homeworksEdited->contains($homeworksEdited)) {
$this->homeworksEdited->add($homeworksEdited);
$homeworksEdited->setEditor($this);
}
return $this;
}
public function removeHomeworksEdited(HomeWork $homeworksEdited): static
{
if ($this->homeworksEdited->removeElement($homeworksEdited)) {
// set the owning side to null (unless already changed)
if ($homeworksEdited->getEditor() === $this) {
$homeworksEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, Late>
*/
public function getLates(): Collection
{
return $this->lates;
}
public function addLate(Late $late): static
{
if (!$this->lates->contains($late)) {
$this->lates->add($late);
$late->setAuthor($this);
}
return $this;
}
public function removeLate(Late $late): static
{
if ($this->lates->removeElement($late)) {
// set the owning side to null (unless already changed)
if ($late->getAuthor() === $this) {
$late->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, Late>
*/
public function getLatesEdited(): Collection
{
return $this->latesEdited;
}
public function addLatesEdited(Late $latesEdited): static
{
if (!$this->latesEdited->contains($latesEdited)) {
$this->latesEdited->add($latesEdited);
$latesEdited->setEditor($this);
}
return $this;
}
public function removeLatesEdited(Late $latesEdited): static
{
if ($this->latesEdited->removeElement($latesEdited)) {
// set the owning side to null (unless already changed)
if ($latesEdited->getEditor() === $this) {
$latesEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, NewsCategory>
*/
public function getNewsCategories(): Collection
{
return $this->newsCategories;
}
public function addNewsCategory(NewsCategory $newsCategory): static
{
if (!$this->newsCategories->contains($newsCategory)) {
$this->newsCategories->add($newsCategory);
$newsCategory->setAuthor($this);
}
return $this;
}
public function removeNewsCategory(NewsCategory $newsCategory): static
{
if ($this->newsCategories->removeElement($newsCategory)) {
// set the owning side to null (unless already changed)
if ($newsCategory->getAuthor() === $this) {
$newsCategory->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, NewsCategory>
*/
public function getNewsCategoriesEdited(): Collection
{
return $this->newsCategoriesEdited;
}
public function addNewsCategoriesEdited(NewsCategory $newsCategoriesEdited): static
{
if (!$this->newsCategoriesEdited->contains($newsCategoriesEdited)) {
$this->newsCategoriesEdited->add($newsCategoriesEdited);
$newsCategoriesEdited->setEditor($this);
}
return $this;
}
public function removeNewsCategoriesEdited(NewsCategory $newsCategoriesEdited): static
{
if ($this->newsCategoriesEdited->removeElement($newsCategoriesEdited)) {
// set the owning side to null (unless already changed)
if ($newsCategoriesEdited->getEditor() === $this) {
$newsCategoriesEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, Note>
*/
public function getNotes(): Collection
{
return $this->notes;
}
public function addNote(Note $note): static
{
if (!$this->notes->contains($note)) {
$this->notes->add($note);
$note->setAuthor($this);
}
return $this;
}
public function removeNote(Note $note): static
{
if ($this->notes->removeElement($note)) {
// set the owning side to null (unless already changed)
if ($note->getAuthor() === $this) {
$note->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, Note>
*/
public function getNotesEdited(): Collection
{
return $this->notesEdited;
}
public function addNotesEdited(Note $notesEdited): static
{
if (!$this->notesEdited->contains($notesEdited)) {
$this->notesEdited->add($notesEdited);
$notesEdited->setEditor($this);
}
return $this;
}
public function removeNotesEdited(Note $notesEdited): static
{
if ($this->notesEdited->removeElement($notesEdited)) {
// set the owning side to null (unless already changed)
if ($notesEdited->getEditor() === $this) {
$notesEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, SchoolSection>
*/
public function getSchoolSections(): Collection
{
return $this->schoolSections;
}
public function addSchoolSection(SchoolSection $schoolSection): static
{
if (!$this->schoolSections->contains($schoolSection)) {
$this->schoolSections->add($schoolSection);
$schoolSection->setAuthor($this);
}
return $this;
}
public function removeSchoolSection(SchoolSection $schoolSection): static
{
if ($this->schoolSections->removeElement($schoolSection)) {
// set the owning side to null (unless already changed)
if ($schoolSection->getAuthor() === $this) {
$schoolSection->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, SchoolSection>
*/
public function getSchoolSectionsEdited(): Collection
{
return $this->schoolSectionsEdited;
}
public function addSchoolSectionsEdited(SchoolSection $schoolSectionsEdited): static
{
if (!$this->schoolSectionsEdited->contains($schoolSectionsEdited)) {
$this->schoolSectionsEdited->add($schoolSectionsEdited);
$schoolSectionsEdited->setEditor($this);
}
return $this;
}
public function removeSchoolSectionsEdited(SchoolSection $schoolSectionsEdited): static
{
if ($this->schoolSectionsEdited->removeElement($schoolSectionsEdited)) {
// set the owning side to null (unless already changed)
if ($schoolSectionsEdited->getEditor() === $this) {
$schoolSectionsEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, SchoolYear>
*/
public function getSchoolYears(): Collection
{
return $this->schoolYears;
}
public function addSchoolYear(SchoolYear $schoolYear): static
{
if (!$this->schoolYears->contains($schoolYear)) {
$this->schoolYears->add($schoolYear);
$schoolYear->setAuthor($this);
}
return $this;
}
public function removeSchoolYear(SchoolYear $schoolYear): static
{
if ($this->schoolYears->removeElement($schoolYear)) {
// set the owning side to null (unless already changed)
if ($schoolYear->getAuthor() === $this) {
$schoolYear->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, SchoolYear>
*/
public function getSchoolYearsEdited(): Collection
{
return $this->schoolYearsEdited;
}
public function addSchoolYearsEdited(SchoolYear $schoolYearsEdited): static
{
if (!$this->schoolYearsEdited->contains($schoolYearsEdited)) {
$this->schoolYearsEdited->add($schoolYearsEdited);
$schoolYearsEdited->setEditor($this);
}
return $this;
}
public function removeSchoolYearsEdited(SchoolYear $schoolYearsEdited): static
{
if ($this->schoolYearsEdited->removeElement($schoolYearsEdited)) {
// set the owning side to null (unless already changed)
if ($schoolYearsEdited->getEditor() === $this) {
$schoolYearsEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, Student>
*/
public function getStudentsEdited(): Collection
{
return $this->studentsEdited;
}
public function addStudentsEdited(Student $studentsEdited): static
{
if (!$this->studentsEdited->contains($studentsEdited)) {
$this->studentsEdited->add($studentsEdited);
$studentsEdited->setEditor($this);
}
return $this;
}
public function removeStudentsEdited(Student $studentsEdited): static
{
if ($this->studentsEdited->removeElement($studentsEdited)) {
// set the owning side to null (unless already changed)
if ($studentsEdited->getEditor() === $this) {
$studentsEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, Subject>
*/
public function getSubjectsEdited(): Collection
{
return $this->subjectsEdited;
}
public function addSubjectsEdited(Subject $subjectsEdited): static
{
if (!$this->subjectsEdited->contains($subjectsEdited)) {
$this->subjectsEdited->add($subjectsEdited);
$subjectsEdited->setEditor($this);
}
return $this;
}
public function removeSubjectsEdited(Subject $subjectsEdited): static
{
if ($this->subjectsEdited->removeElement($subjectsEdited)) {
// set the owning side to null (unless already changed)
if ($subjectsEdited->getEditor() === $this) {
$subjectsEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, SubjectGroup>
*/
public function getSubjectGroups(): Collection
{
return $this->subjectGroups;
}
public function addSubjectGroup(SubjectGroup $subjectGroup): static
{
if (!$this->subjectGroups->contains($subjectGroup)) {
$this->subjectGroups->add($subjectGroup);
$subjectGroup->setAuthor($this);
}
return $this;
}
public function removeSubjectGroup(SubjectGroup $subjectGroup): static
{
if ($this->subjectGroups->removeElement($subjectGroup)) {
// set the owning side to null (unless already changed)
if ($subjectGroup->getAuthor() === $this) {
$subjectGroup->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, SubjectGroup>
*/
public function getSubjectGroupsEdited(): Collection
{
return $this->subjectGroupsEdited;
}
public function addSubjectGroupsEdited(SubjectGroup $subjectGroupsEdited): static
{
if (!$this->subjectGroupsEdited->contains($subjectGroupsEdited)) {
$this->subjectGroupsEdited->add($subjectGroupsEdited);
$subjectGroupsEdited->setEditor($this);
}
return $this;
}
public function removeSubjectGroupsEdited(SubjectGroup $subjectGroupsEdited): static
{
if ($this->subjectGroupsEdited->removeElement($subjectGroupsEdited)) {
// set the owning side to null (unless already changed)
if ($subjectGroupsEdited->getEditor() === $this) {
$subjectGroupsEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, TheClass>
*/
public function getTheClasses(): Collection
{
return $this->theClasses;
}
public function addTheClass(TheClass $theClass): static
{
if (!$this->theClasses->contains($theClass)) {
$this->theClasses->add($theClass);
$theClass->setAuthor($this);
}
return $this;
}
public function removeTheClass(TheClass $theClass): static
{
if ($this->theClasses->removeElement($theClass)) {
// set the owning side to null (unless already changed)
if ($theClass->getAuthor() === $this) {
$theClass->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, TheClass>
*/
public function getTheClassesEdited(): Collection
{
return $this->theClassesEdited;
}
public function addTheClassesEdited(TheClass $theClassesEdited): static
{
if (!$this->theClassesEdited->contains($theClassesEdited)) {
$this->theClassesEdited->add($theClassesEdited);
$theClassesEdited->setEditor($this);
}
return $this;
}
public function removeTheClassesEdited(TheClass $theClassesEdited): static
{
if ($this->theClassesEdited->removeElement($theClassesEdited)) {
// set the owning side to null (unless already changed)
if ($theClassesEdited->getEditor() === $this) {
$theClassesEdited->setEditor(null);
}
}
return $this;
}
public function getAuthor(): ?self
{
return $this->author;
}
public function setAuthor(?self $author): static
{
$this->author = $author;
return $this;
}
/**
* @return Collection<int, self>
*/
public function getUsers(): Collection
{
return $this->users;
}
public function addUser(self $user): static
{
if (!$this->users->contains($user)) {
$this->users->add($user);
$user->setAuthor($this);
}
return $this;
}
public function removeUser(self $user): static
{
if ($this->users->removeElement($user)) {
// set the owning side to null (unless already changed)
if ($user->getAuthor() === $this) {
$user->setAuthor(null);
}
}
return $this;
}
public function getEditor(): ?self
{
return $this->editor;
}
public function setEditor(?self $editor): static
{
$this->editor = $editor;
return $this;
}
/**
* @return Collection<int, self>
*/
public function getUsersEdited(): Collection
{
return $this->usersEdited;
}
public function addUsersEdited(self $usersEdited): static
{
if (!$this->usersEdited->contains($usersEdited)) {
$this->usersEdited->add($usersEdited);
$usersEdited->setEditor($this);
}
return $this;
}
public function removeUsersEdited(self $usersEdited): static
{
if ($this->usersEdited->removeElement($usersEdited)) {
// set the owning side to null (unless already changed)
if ($usersEdited->getEditor() === $this) {
$usersEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, Student>
*/
public function getStudentsCreated(): Collection
{
return $this->studentsCreated;
}
public function addStudentsCreated(Student $studentsCreated): static
{
if (!$this->studentsCreated->contains($studentsCreated)) {
$this->studentsCreated->add($studentsCreated);
$studentsCreated->setAuthor($this);
}
return $this;
}
public function removeStudentsCreated(Student $studentsCreated): static
{
if ($this->studentsCreated->removeElement($studentsCreated)) {
// set the owning side to null (unless already changed)
if ($studentsCreated->getAuthor() === $this) {
$studentsCreated->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, Subject>
*/
public function getSubjectsCreated(): Collection
{
return $this->subjectsCreated;
}
public function addSubjectsCreated(Subject $subjectsCreated): static
{
if (!$this->subjectsCreated->contains($subjectsCreated)) {
$this->subjectsCreated->add($subjectsCreated);
$subjectsCreated->setAuthor($this);
}
return $this;
}
public function removeSubjectsCreated(Subject $subjectsCreated): static
{
if ($this->subjectsCreated->removeElement($subjectsCreated)) {
// set the owning side to null (unless already changed)
if ($subjectsCreated->getAuthor() === $this) {
$subjectsCreated->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, News>
*/
public function getNewsEdited(): Collection
{
return $this->newsEdited;
}
public function addNewsEdited(News $newsEdited): static
{
if (!$this->newsEdited->contains($newsEdited)) {
$this->newsEdited->add($newsEdited);
$newsEdited->setEditor($this);
}
return $this;
}
public function removeNewsEdited(News $newsEdited): static
{
if ($this->newsEdited->removeElement($newsEdited)) {
// set the owning side to null (unless already changed)
if ($newsEdited->getEditor() === $this) {
$newsEdited->setEditor(null);
}
}
return $this;
}
/**
* @return Collection<int, PunishCategory>
*/
public function getPunishCategories(): Collection
{
return $this->punishCategories;
}
public function addPunishCategory(PunishCategory $punishCategory): static
{
if (!$this->punishCategories->contains($punishCategory)) {
$this->punishCategories->add($punishCategory);
$punishCategory->setAuthor($this);
}
return $this;
}
public function removePunishCategory(PunishCategory $punishCategory): static
{
if ($this->punishCategories->removeElement($punishCategory)) {
// set the owning side to null (unless already changed)
if ($punishCategory->getAuthor() === $this) {
$punishCategory->setAuthor(null);
}
}
return $this;
}
public function getLastRequestTs(): ?string
{
return $this->lastRequestTs;
}
public function setLastRequestTs(?string $lastRequestTs): static
{
$this->lastRequestTs = $lastRequestTs;
return $this;
}
public function getSchool(): ?School
{
return $this->school;
}
public function setSchool(?School $school): static
{
$this->school = $school;
return $this;
}
/**
* @return Collection<int, DiscussionClassMessage>
*/
public function getDiscussionClassMessages(): Collection
{
return $this->discussionClassMessages;
}
public function addDiscussionClassMessage(DiscussionClassMessage $discussionClassMessage): static
{
if (!$this->discussionClassMessages->contains($discussionClassMessage)) {
$this->discussionClassMessages->add($discussionClassMessage);
$discussionClassMessage->setAuthor($this);
}
return $this;
}
public function removeDiscussionClassMessage(DiscussionClassMessage $discussionClassMessage): static
{
if ($this->discussionClassMessages->removeElement($discussionClassMessage)) {
// set the owning side to null (unless already changed)
if ($discussionClassMessage->getAuthor() === $this) {
$discussionClassMessage->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, Agenda>
*/
public function getAgendas(): Collection
{
return $this->agendas;
}
public function addAgenda(Agenda $agenda): static
{
if (!$this->agendas->contains($agenda)) {
$this->agendas->add($agenda);
$agenda->setAuthor($this);
}
return $this;
}
public function removeAgenda(Agenda $agenda): static
{
if ($this->agendas->removeElement($agenda)) {
// set the owning side to null (unless already changed)
if ($agenda->getAuthor() === $this) {
$agenda->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, ExamAgenda>
*/
public function getExamAgendas(): Collection
{
return $this->examAgendas;
}
public function addExamAgenda(ExamAgenda $examAgenda): static
{
if (!$this->examAgendas->contains($examAgenda)) {
$this->examAgendas->add($examAgenda);
$examAgenda->setAuthor($this);
}
return $this;
}
public function removeExamAgenda(ExamAgenda $examAgenda): static
{
if ($this->examAgendas->removeElement($examAgenda)) {
// set the owning side to null (unless already changed)
if ($examAgenda->getAuthor() === $this) {
$examAgenda->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, SubSequence>
*/
public function getSubSequences(): Collection
{
return $this->subSequences;
}
public function addSubSequence(SubSequence $subSequence): static
{
if (!$this->subSequences->contains($subSequence)) {
$this->subSequences->add($subSequence);
$subSequence->setAuthor($this);
}
return $this;
}
public function removeSubSequence(SubSequence $subSequence): static
{
if ($this->subSequences->removeElement($subSequence)) {
// set the owning side to null (unless already changed)
if ($subSequence->getAuthor() === $this) {
$subSequence->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, Quarter>
*/
public function getQuarters(): Collection
{
return $this->quarters;
}
public function addQuarter(Quarter $quarter): static
{
if (!$this->quarters->contains($quarter)) {
$this->quarters->add($quarter);
$quarter->setAuthor($this);
}
return $this;
}
public function removeQuarter(Quarter $quarter): static
{
if ($this->quarters->removeElement($quarter)) {
// set the owning side to null (unless already changed)
if ($quarter->getAuthor() === $this) {
$quarter->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, SubNote>
*/
public function getSubNotes(): Collection
{
return $this->subNotes;
}
public function addSubNote(SubNote $subNote): static
{
if (!$this->subNotes->contains($subNote)) {
$this->subNotes->add($subNote);
$subNote->setAuthor($this);
}
return $this;
}
public function removeSubNote(SubNote $subNote): static
{
if ($this->subNotes->removeElement($subNote)) {
// set the owning side to null (unless already changed)
if ($subNote->getAuthor() === $this) {
$subNote->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, AgendaDay>
*/
public function getAgendaDays(): Collection
{
return $this->agendaDays;
}
public function addAgendaDay(AgendaDay $agendaDay): static
{
if (!$this->agendaDays->contains($agendaDay)) {
$this->agendaDays->add($agendaDay);
$agendaDay->setAuthor($this);
}
return $this;
}
public function removeAgendaDay(AgendaDay $agendaDay): static
{
if ($this->agendaDays->removeElement($agendaDay)) {
// set the owning side to null (unless already changed)
if ($agendaDay->getAuthor() === $this) {
$agendaDay->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, AgendaElement>
*/
public function getAgendaElements(): Collection
{
return $this->agendaElements;
}
public function addAgendaElement(AgendaElement $agendaElement): static
{
if (!$this->agendaElements->contains($agendaElement)) {
$this->agendaElements->add($agendaElement);
$agendaElement->setAuthor($this);
}
return $this;
}
public function removeAgendaElement(AgendaElement $agendaElement): static
{
if ($this->agendaElements->removeElement($agendaElement)) {
// set the owning side to null (unless already changed)
if ($agendaElement->getAuthor() === $this) {
$agendaElement->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, ExamAgendaDay>
*/
public function getExamAgendaDays(): Collection
{
return $this->examAgendaDays;
}
public function addExamAgendaDay(ExamAgendaDay $examAgendaDay): static
{
if (!$this->examAgendaDays->contains($examAgendaDay)) {
$this->examAgendaDays->add($examAgendaDay);
$examAgendaDay->setAuthor($this);
}
return $this;
}
public function removeExamAgendaDay(ExamAgendaDay $examAgendaDay): static
{
if ($this->examAgendaDays->removeElement($examAgendaDay)) {
// set the owning side to null (unless already changed)
if ($examAgendaDay->getAuthor() === $this) {
$examAgendaDay->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, ExamAgendaElement>
*/
public function getExamAgendaElements(): Collection
{
return $this->examAgendaElements;
}
public function addExamAgendaElement(ExamAgendaElement $examAgendaElement): static
{
if (!$this->examAgendaElements->contains($examAgendaElement)) {
$this->examAgendaElements->add($examAgendaElement);
$examAgendaElement->setAuthor($this);
}
return $this;
}
public function removeExamAgendaElement(ExamAgendaElement $examAgendaElement): static
{
if ($this->examAgendaElements->removeElement($examAgendaElement)) {
// set the owning side to null (unless already changed)
if ($examAgendaElement->getAuthor() === $this) {
$examAgendaElement->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, Appreciation>
*/
public function getAppreciations(): Collection
{
return $this->appreciations;
}
public function addAppreciation(Appreciation $appreciation): static
{
if (!$this->appreciations->contains($appreciation)) {
$this->appreciations->add($appreciation);
$appreciation->setAuthor($this);
}
return $this;
}
public function removeAppreciation(Appreciation $appreciation): static
{
if ($this->appreciations->removeElement($appreciation)) {
// set the owning side to null (unless already changed)
if ($appreciation->getAuthor() === $this) {
$appreciation->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, LocalAccount>
*/
public function getLocalAccounts(): Collection
{
return $this->localAccounts;
}
public function addLocalAccount(LocalAccount $localAccount): static
{
if (!$this->localAccounts->contains($localAccount)) {
$this->localAccounts->add($localAccount);
$localAccount->setUser($this);
}
return $this;
}
public function removeLocalAccount(LocalAccount $localAccount): static
{
if ($this->localAccounts->removeElement($localAccount)) {
// set the owning side to null (unless already changed)
if ($localAccount->getUser() === $this) {
$localAccount->setUser(null);
}
}
return $this;
}
/**
* @return Collection<int, NewsBookmark>
*/
public function getNewsBookmarks(): Collection
{
return $this->newsBookmarks;
}
public function addNewsBookmark(NewsBookmark $newsBookmark): static
{
if (!$this->newsBookmarks->contains($newsBookmark)) {
$this->newsBookmarks->add($newsBookmark);
$newsBookmark->setUser($this);
}
return $this;
}
/**
* @return Collection<int, ScolarityHistory>
*/
public function getScolarityHistories(): Collection
{
return $this->scolarityHistories;
}
public function addScolarityHistory(ScolarityHistory $scolarityHistory): static
{
if (!$this->scolarityHistories->contains($scolarityHistory)) {
$this->scolarityHistories->add($scolarityHistory);
$scolarityHistory->setAuthor($this);
}
return $this;
}
public function removeNewsBookmark(NewsBookmark $newsBookmark): static
{
if ($this->newsBookmarks->removeElement($newsBookmark)) {
// set the owning side to null (unless already changed)
if ($newsBookmark->getUser() === $this) {
$newsBookmark->setUser(null);
}
return $this;
}
}
public function removeScolarityHistory(ScolarityHistory $scolarityHistory): static
{
if ($this->scolarityHistories->removeElement($scolarityHistory)) {
// set the owning side to null (unless already changed)
if ($scolarityHistory->getAuthor() === $this) {
$scolarityHistory->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, HomeworkBookmark>
*/
public function getHomeworkBookmarks(): Collection
{
return $this->homeworkBookmarks;
}
public function addHomeworkBookmark(HomeworkBookmark $homeworkBookmark): static
{
if (!$this->homeworkBookmarks->contains($homeworkBookmark)) {
$this->homeworkBookmarks->add($homeworkBookmark);
$homeworkBookmark->setUser($this);
}
return $this;
}
/**
* @return Collection<int, ScolarityHistoryEdition>
*/
public function getScolarityHistoryEditions(): Collection
{
return $this->scolarityHistoryEditions;
}
public function addScolarityHistoryEditon(ScolarityHistoryEdition $scolarityHistoryEdition): static
{
if (!$this->scolarityHistoryEditions->contains($scolarityHistoryEdition)) {
$this->scolarityHistoryEditions->add($scolarityHistoryEdition);
$scolarityHistoryEdition->setAuthor($this);
}
return $this;
}
public function removeHomeworkBookmark(HomeworkBookmark $homeworkBookmark): static
{
if ($this->homeworkBookmarks->removeElement($homeworkBookmark)) {
// set the owning side to null (unless already changed)
if ($homeworkBookmark->getUser() === $this) {
$homeworkBookmark->setUser(null);
}
return $this;
}
}
public function removeScolarityHistoryEdition(ScolarityHistoryEdition $scolarityHistoryEdition): static
{
if ($this->scolarityHistoryEditions->removeElement($scolarityHistoryEdition)) {
// set the owning side to null (unless already changed)
if ($scolarityHistoryEdition->getAuthor() === $this) {
$scolarityHistoryEdition->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, JustifyAbsence>
*/
public function getJustifyAbsences(): Collection
{
return $this->justifyAbsences;
}
public function addJustifyAbsence(JustifyAbsence $justifyAbsence): static
{
if (!$this->justifyAbsences->contains($justifyAbsence)) {
$this->justifyAbsences->add($justifyAbsence);
$justifyAbsence->setAuthor($this);
}
return $this;
}
public function removeJustifyAbsence(JustifyAbsence $justifyAbsence): static
{
if ($this->justifyAbsences->removeElement($justifyAbsence)) {
// set the owning side to null (unless already changed)
if ($justifyAbsence->getAuthor() === $this) {
$justifyAbsence->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, VerbalProcess>
*/
public function getVerbalProcesses(): Collection
{
return $this->verbalProcesses;
}
public function addVerbalProcess(VerbalProcess $verbalProcess): static
{
if (!$this->verbalProcesses->contains($verbalProcess)) {
$this->verbalProcesses->add($verbalProcess);
$verbalProcess->setAuthor($this);
}
return $this;
}
public function removeVerbalProcess(VerbalProcess $verbalProcess): static
{
if ($this->verbalProcesses->removeElement($verbalProcess)) {
// set the owning side to null (unless already changed)
if ($verbalProcess->getAuthor() === $this) {
$verbalProcess->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, AbsenceDisciplineConcileConfig>
*/
public function getAbsenceDisciplineConcileConfigs(): Collection
{
return $this->absenceDisciplineConcileConfigs;
}
public function addAbsenceDisciplineConcileConfig(AbsenceDisciplineConcileConfig $absenceDisciplineConcileConfig): static
{
if (!$this->absenceDisciplineConcileConfigs->contains($absenceDisciplineConcileConfig)) {
$this->absenceDisciplineConcileConfigs->add($absenceDisciplineConcileConfig);
$absenceDisciplineConcileConfig->setAuthor($this);
}
return $this;
}
public function removeAbsenceDisciplineConcileConfig(AbsenceDisciplineConcileConfig $absenceDisciplineConcileConfig): static
{
if ($this->absenceDisciplineConcileConfigs->removeElement($absenceDisciplineConcileConfig)) {
// set the owning side to null (unless already changed)
if ($absenceDisciplineConcileConfig->getAuthor() === $this) {
$absenceDisciplineConcileConfig->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, TheClass>
*/
public function getTheClassesTeached(): Collection
{
return $this->theClassesTeached;
}
public function addTheClassesTeached(TheClass $theClassesTeached): static
{
if (!$this->theClassesTeached->contains($theClassesTeached)) {
$this->theClassesTeached->add($theClassesTeached);
$theClassesTeached->setProf($this);
}
return $this;
}
public function removeTheClassesTeached(TheClass $theClassesTeached): static
{
if ($this->theClassesTeached->removeElement($theClassesTeached)) {
// set the owning side to null (unless already changed)
if ($theClassesTeached->getProf() === $this) {
$theClassesTeached->setProf(null);
}
}
return $this;
}
/**
* @return Collection<int, PrimaryNote>
*/
public function getPrimaryNotes(): Collection
{
return $this->primaryNotes;
}
public function addPrimaryNote(PrimaryNote $primaryNote): static
{
if (!$this->primaryNotes->contains($primaryNote)) {
$this->primaryNotes->add($primaryNote);
$primaryNote->setAuthor($this);
}
return $this;
}
public function removePrimaryNote(PrimaryNote $primaryNote): static
{
if ($this->primaryNotes->removeElement($primaryNote)) {
// set the owning side to null (unless already changed)
if ($primaryNote->getAuthor() === $this) {
$primaryNote->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, VerbalProcessCategory>
*/
public function getVerbalProcessCategories(): Collection
{
return $this->verbalProcessCategories;
}
public function addVerbalProcessCategory(VerbalProcessCategory $verbalProcessCategory): static
{
if (!$this->verbalProcessCategories->contains($verbalProcessCategory)) {
$this->verbalProcessCategories->add($verbalProcessCategory);
$verbalProcessCategory->setAuthor($this);
}
return $this;
}
public function removeVerbalProcessCategory(VerbalProcessCategory $verbalProcessCategory): static
{
if ($this->verbalProcessCategories->removeElement($verbalProcessCategory)) {
// set the owning side to null (unless already changed)
if ($verbalProcessCategory->getAuthor() === $this) {
$verbalProcessCategory->setAuthor(null);
}
}
return $this;
}
public function getTheme(): ?string
{
return $this->theme;
}
public function setTheme(?string $theme): static
{
$this->theme = $theme;
return $this;
}
public function getPicture(): ?string
{
return $this->picture;
}
public function setPicture(?string $picture): static
{
$this->picture = $picture;
return $this;
}
public function getSexe(): ?string
{
return $this->sexe;
}
public function setSexe(?string $sexe): static
{
$this->sexe = $sexe;
return $this;
}
/**
* @return Collection<int, UserAndroidToken>
*/
public function getUserAndroidTokens(): Collection
{
return $this->userAndroidTokens;
}
public function addUserAndroidToken(UserAndroidToken $userAndroidToken): static
{
if (!$this->userAndroidTokens->contains($userAndroidToken)) {
$this->userAndroidTokens->add($userAndroidToken);
$userAndroidToken->setUser($this);
}
return $this;
}
public function removeUserAndroidToken(UserAndroidToken $userAndroidToken): static
{
if ($this->userAndroidTokens->removeElement($userAndroidToken)) {
// set the owning side to null (unless already changed)
if ($userAndroidToken->getUser() === $this) {
$userAndroidToken->setUser(null);
}
}
return $this;
}
/**
* @return Collection<int, UserIphoneToken>
*/
public function getUserIphoneTokens(): Collection
{
return $this->userIphoneTokens;
}
public function addUserIphoneToken(UserIphoneToken $userIphoneToken): static
{
if (!$this->userIphoneTokens->contains($userIphoneToken)) {
$this->userIphoneTokens->add($userIphoneToken);
$userIphoneToken->setUser($this);
}
return $this;
}
public function removeUserIphoneToken(UserIphoneToken $userIphoneToken): static
{
if ($this->userIphoneTokens->removeElement($userIphoneToken)) {
// set the owning side to null (unless already changed)
if ($userIphoneToken->getUser() === $this) {
$userIphoneToken->setUser(null);
}
}
return $this;
}
public function getLocalPhoneLang(): ?string
{
return $this->localPhoneLang;
}
public function setLocalPhoneLang(?string $localPhoneLang): static
{
$this->localPhoneLang = $localPhoneLang;
return $this;
}
/**
* @return Collection<int, AbsenceBlameConfig>
*/
public function getAbsenceBlameConfigs(): Collection
{
return $this->absenceBlameConfigs;
}
public function addAbsenceBlameConfig(AbsenceBlameConfig $absenceBlameConfig): static
{
if (!$this->absenceBlameConfigs->contains($absenceBlameConfig)) {
$this->absenceBlameConfigs->add($absenceBlameConfig);
$absenceBlameConfig->setAuthor($this);
}
return $this;
}
public function removeAbsenceBlameConfig(AbsenceBlameConfig $absenceBlameConfig): static
{
if ($this->absenceBlameConfigs->removeElement($absenceBlameConfig)) {
// set the owning side to null (unless already changed)
if ($absenceBlameConfig->getAuthor() === $this) {
$absenceBlameConfig->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, AbsenceWarningConfig>
*/
public function getAbsenceWarningConfigs(): Collection
{
return $this->absenceWarningConfigs;
}
public function addAbsenceWarningConfig(AbsenceWarningConfig $absenceWarningConfig): static
{
if (!$this->absenceWarningConfigs->contains($absenceWarningConfig)) {
$this->absenceWarningConfigs->add($absenceWarningConfig);
$absenceWarningConfig->setAuthor($this);
}
return $this;
}
public function removeAbsenceWarningConfig(AbsenceWarningConfig $absenceWarningConfig): static
{
if ($this->absenceWarningConfigs->removeElement($absenceWarningConfig)) {
// set the owning side to null (unless already changed)
if ($absenceWarningConfig->getAuthor() === $this) {
$absenceWarningConfig->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, AbsencePunishConfig>
*/
public function getAbsencePunishConfigs(): Collection
{
return $this->absencePunishConfigs;
}
public function addAbsencePunishConfig(AbsencePunishConfig $absencePunishConfig): static
{
if (!$this->absencePunishConfigs->contains($absencePunishConfig)) {
$this->absencePunishConfigs->add($absencePunishConfig);
$absencePunishConfig->setAuthor($this);
}
return $this;
}
public function removeAbsencePunishConfig(AbsencePunishConfig $absencePunishConfig): static
{
if ($this->absencePunishConfigs->removeElement($absencePunishConfig)) {
// set the owning side to null (unless already changed)
if ($absencePunishConfig->getAuthor() === $this) {
$absencePunishConfig->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, AbsenceExclusionConfig>
*/
public function getAbsenceExclusionConfigs(): Collection
{
return $this->absenceExclusionConfigs;
}
public function addAbsenceExclusionConfig(AbsenceExclusionConfig $absenceExclusionConfig): static
{
if (!$this->absenceExclusionConfigs->contains($absenceExclusionConfig)) {
$this->absenceExclusionConfigs->add($absenceExclusionConfig);
$absenceExclusionConfig->setAuthor($this);
}
return $this;
}
public function removeAbsenceExclusionConfig(AbsenceExclusionConfig $absenceExclusionConfig): static
{
if ($this->absenceExclusionConfigs->removeElement($absenceExclusionConfig)) {
// set the owning side to null (unless already changed)
if ($absenceExclusionConfig->getAuthor() === $this) {
$absenceExclusionConfig->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, GlobalDisciplineEnabledConfig>
*/
public function getGlobalDisciplineEnabledConfigs(): Collection
{
return $this->globalDisciplineEnabledConfigs;
}
public function addGlobalDisciplineEnabledConfig(GlobalDisciplineEnabledConfig $globalDisciplineEnabledConfig): static
{
if (!$this->globalDisciplineEnabledConfigs->contains($globalDisciplineEnabledConfig)) {
$this->globalDisciplineEnabledConfigs->add($globalDisciplineEnabledConfig);
$globalDisciplineEnabledConfig->setAuthor($this);
}
return $this;
}
public function removeGlobalDisciplineEnabledConfig(GlobalDisciplineEnabledConfig $globalDisciplineEnabledConfig): static
{
if ($this->globalDisciplineEnabledConfigs->removeElement($globalDisciplineEnabledConfig)) {
// set the owning side to null (unless already changed)
if ($globalDisciplineEnabledConfig->getAuthor() === $this) {
$globalDisciplineEnabledConfig->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, AbsenceRetainedConfig>
*/
public function getAbsenceRetainedConfigs(): Collection
{
return $this->absenceRetainedConfigs;
}
public function addAbsenceRetainedConfig(AbsenceRetainedConfig $absenceRetainedConfig): static
{
if (!$this->absenceRetainedConfigs->contains($absenceRetainedConfig)) {
$this->absenceRetainedConfigs->add($absenceRetainedConfig);
$absenceRetainedConfig->setAuthor($this);
}
return $this;
}
public function removeAbsenceRetainedConfig(AbsenceRetainedConfig $absenceRetainedConfig): static
{
if ($this->absenceRetainedConfigs->removeElement($absenceRetainedConfig)) {
// set the owning side to null (unless already changed)
if ($absenceRetainedConfig->getAuthor() === $this) {
$absenceRetainedConfig->setAuthor(null);
}
}
return $this;
}
public function getUserToken(): ?string
{
return $this->userToken;
}
public function setUserToken(?string $userToken): static
{
$this->userToken = $userToken;
return $this;
}
/**
* @return Collection<int, DisciplineConcile>
*/
public function getDisciplineConciles(): Collection
{
return $this->disciplineConciles;
}
public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
{
if (!$this->disciplineConciles->contains($disciplineConcile)) {
$this->disciplineConciles->add($disciplineConcile);
$disciplineConcile->setAuthor($this);
}
return $this;
}
public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
{
if ($this->disciplineConciles->removeElement($disciplineConcile)) {
// set the owning side to null (unless already changed)
if ($disciplineConcile->getAuthor() === $this) {
$disciplineConcile->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, RefreshToken>
*/
public function getRefreshTokens(): Collection
{
return $this->refreshTokens;
}
public function addRefreshToken(RefreshToken $refreshToken): static
{
if (!$this->refreshTokens->contains($refreshToken)) {
$this->refreshTokens->add($refreshToken);
$refreshToken->setUser($this);
}
return $this;
}
public function removeRefreshToken(RefreshToken $refreshToken): static
{
if ($this->refreshTokens->removeElement($refreshToken)) {
// set the owning side to null (unless already changed)
if ($refreshToken->getUser() === $this) {
$refreshToken->setUser(null);
}
}
return $this;
}
/**
* @return Collection<int, UserNotification>
*/
public function getUserNotifications(): Collection
{
return $this->userNotifications;
}
public function addUserNotification(UserNotification $userNotification): static
{
if (!$this->userNotifications->contains($userNotification)) {
$this->userNotifications->add($userNotification);
$userNotification->setUser($this);
}
return $this;
}
public function removeUserNotification(UserNotification $userNotification): static
{
if ($this->userNotifications->removeElement($userNotification)) {
// set the owning side to null (unless already changed)
if ($userNotification->getUser() === $this) {
$userNotification->setUser(null);
}
}
return $this;
}
/**
* @return Collection<int, DiscussionClassMessage>
*/
public function getDiscussionClassMessagesRead(): Collection
{
return $this->discussionClassMessagesRead;
}
public function addDiscussionClassMessagesRead(DiscussionClassMessage $discussionClassMessagesRead): static
{
if (!$this->discussionClassMessagesRead->contains($discussionClassMessagesRead)) {
$this->discussionClassMessagesRead->add($discussionClassMessagesRead);
$discussionClassMessagesRead->addReader($this);
}
return $this;
}
public function removeDiscussionClassMessagesRead(DiscussionClassMessage $discussionClassMessagesRead): static
{
if ($this->discussionClassMessagesRead->removeElement($discussionClassMessagesRead)) {
$discussionClassMessagesRead->removeReader($this);
}
return $this;
}
/**
* @return Collection<int, AgendaTimeConvertion>
*/
public function getAgendaTimeConvertions(): Collection
{
return $this->agendaTimeConvertions;
}
public function addAgendaTimeConvertion(AgendaTimeConvertion $agendaTimeConvertion): static
{
if (!$this->agendaTimeConvertions->contains($agendaTimeConvertion)) {
$this->agendaTimeConvertions->add($agendaTimeConvertion);
$agendaTimeConvertion->setAuthor($this);
}
return $this;
}
public function removeAgendaTimeConvertion(AgendaTimeConvertion $agendaTimeConvertion): static
{
if ($this->agendaTimeConvertions->removeElement($agendaTimeConvertion)) {
// set the owning side to null (unless already changed)
if ($agendaTimeConvertion->getAuthor() === $this) {
$agendaTimeConvertion->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, Competence>
*/
public function getCompetences(): Collection
{
return $this->competences;
}
public function addCompetence(Competence $competence): static
{
if (!$this->competences->contains($competence)) {
$this->competences->add($competence);
$competence->setAuthor($this);
}
return $this;
}
public function removeCompetence(Competence $competence): static
{
if ($this->competences->removeElement($competence)) {
// set the owning side to null (unless already changed)
if ($competence->getAuthor() === $this) {
$competence->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, ProfTime>
*/
public function getProfTimes(): Collection
{
return $this->profTimes;
}
public function addProfTime(ProfTime $profTime): static
{
if (!$this->profTimes->contains($profTime)) {
$this->profTimes->add($profTime);
$profTime->setProf($this);
}
return $this;
}
public function removeProfTime(ProfTime $profTime): static
{
if ($this->profTimes->removeElement($profTime)) {
// set the owning side to null (unless already changed)
if ($profTime->getProf() === $this) {
$profTime->setProf(null);
}
}
return $this;
}
/**
* @return Collection<int, GlobalSchoolBreak>
*/
public function getGlobalSchoolBreaks(): Collection
{
return $this->globalSchoolBreaks;
}
public function addGlobalSchoolBreak(GlobalSchoolBreak $globalSchoolBreak): static
{
if (!$this->globalSchoolBreaks->contains($globalSchoolBreak)) {
$this->globalSchoolBreaks->add($globalSchoolBreak);
$globalSchoolBreak->setAuthor($this);
}
return $this;
}
public function removeGlobalSchoolBreak(GlobalSchoolBreak $globalSchoolBreak): static
{
if ($this->globalSchoolBreaks->removeElement($globalSchoolBreak)) {
// set the owning side to null (unless already changed)
if ($globalSchoolBreak->getAuthor() === $this) {
$globalSchoolBreak->setAuthor(null);
}
}
return $this;
}
/**
* @return Collection<int, TeacherAbsence>
*/
public function getTeacherAbsences(): Collection
{
return $this->teacherAbsences;
}
public function addTeacherAbsence(TeacherAbsence $teacherAbsence): static
{
if (!$this->teacherAbsences->contains($teacherAbsence)) {
$this->teacherAbsences->add($teacherAbsence);
$teacherAbsence->setTeacher($this);
}
return $this;
}
public function removeTeacherAbsence(TeacherAbsence $teacherAbsence): static
{
if ($this->teacherAbsences->removeElement($teacherAbsence)) {
// set the owning side to null (unless already changed)
if ($teacherAbsence->getTeacher() === $this) {
$teacherAbsence->setTeacher(null);
}
}
return $this;
}
/**
* @return Collection<int, TeacherActivity>
*/
public function getTeacherActivities(): Collection
{
return $this->teacherActivities;
}
public function addTeacherActivity(TeacherActivity $teacherActivity): static
{
if (!$this->teacherActivities->contains($teacherActivity)) {
$this->teacherActivities->add($teacherActivity);
$teacherActivity->setTeacher($this);
}
return $this;
}
public function removeTeacherActivity(TeacherActivity $teacherActivity): static
{
if ($this->teacherActivities->removeElement($teacherActivity)) {
// set the owning side to null (unless already changed)
if ($teacherActivity->getTeacher() === $this) {
$teacherActivity->setTeacher(null);
}
}
return $this;
}
public function getRegionInspect(): ?Region
{
return $this->regionInspect;
}
public function setRegionInspect(?Region $regionInspect): static
{
$this->regionInspect = $regionInspect;
return $this;
}
public function getDepartmentInspect(): ?Department
{
return $this->departmentInspect;
}
public function setDepartmentInspect(?Department $departmentInspect): static
{
$this->departmentInspect = $departmentInspect;
return $this;
}
}

src/Entity/User.php line 20