src/Entity/Attendee.php line 20

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use App\Repository\AttendeeRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  14. use Symfony\UX\Turbo\Attribute\Broadcast;
  16. #[ORM\Entity(repositoryClass: AttendeeRepository::class)]
  17. #[Broadcast]
  18. #[ApiResource]
  19. #[UniqueEntity(fields: ['username'], message: 'There is already an account with this username')]
  20. class Attendee implements UserInterface, PasswordAuthenticatedUserInterface
  21. {
  22.     #[ORM\Id]
  23.     #[ORM\GeneratedValue]
  24.     #[ORM\Column]
  25.     private ?int $id = null;
  27.     #[ORM\Column(length: 180, unique: true)]
  28.     private ?string $username = null;
  30.     #[ORM\Column]
  31.     private array $roles = [];
  33.     /**
  34.      * @var string The hashed password
  35.      */
  36.     #[ORM\Column]
  37.     private ?string $password = null;
  39.     #[ORM\Embedded(class: UserInformation::class)]
  40.     private UserInformation $userInformation;
  42.     #[ORM\Embedded(class: Adress::class)]
  43.     private $billingAdress;
  45.     #[ORM\ManyToOne(inversedBy: 'attendees')]
  46.     private ?Corporation $corporation = null;
  48.     #[ORM\ManyToMany(targetEntity: Course::class, mappedBy: 'attendees')]
  49.     private Collection $courses;
  51.     #[ORM\OneToMany(mappedBy: 'attendee', targetEntity: LessonProgress::class)]
  52.     private Collection $lessonProgress;
  54.     #[ORM\ManyToOne(inversedBy: 'attendees')]
  55.     private ?Portal $portal = null;
  57.     #[ORM\OneToMany(mappedBy: 'attendee', targetEntity: CourseEvaluation::class)]
  58.     private Collection $courseEvaluations;
  60.     #[ORM\ManyToMany(targetEntity: Badge::class, inversedBy: 'attendees')]
  61.     private Collection $badges;
  63.     #[ORM\Column]
  64.     private ?int $mood = null;
  66.     #[ORM\OneToMany(mappedBy: 'attendee', targetEntity: GivenAnswere::class)]
  67.     private Collection $givenAnsweres;
  69.     #[ORM\OneToMany(mappedBy: 'sender', targetEntity: Message::class)]
  70.     private Collection $sendMessages;
  72.     #[ORM\OneToMany(mappedBy: 'receiver', targetEntity: Message::class)]
  73.     private Collection $reveivedMessages;
  75.     #[ORM\Column(type: 'boolean')]
  76.     private $isVerified = false;
  78.     #[ORM\OneToMany(mappedBy: 'attendee', targetEntity: Booking::class)]
  79.     private Collection $bookings;
  81.     #[ORM\OneToMany(mappedBy: 'attendee', targetEntity: LicenseStatus::class)]
  82.     private Collection $licenseStatuses;
  84.     #[ORM\OneToMany(mappedBy: 'attendee', targetEntity: Certificate::class)]
  85.     private Collection $certificates;
  87.     #[ORM\OneToMany(mappedBy: 'attendee', targetEntity: LoggedTime::class)]
  88.     private Collection $loggedTimes;
  90.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  91.     private ?\DateTimeInterface $lastLogin = null;
  93.     public function __construct()
  94.     {
  95.         $this->userInformation = new UserInformation();
  96.         $this->getUserInformation()->setCreatedAt(new \DateTimeImmutable());
  97.         $this->courses = new ArrayCollection();
  98.         $this->lessonProgress = new ArrayCollection();
  99.         $this->courseEvaluations = new ArrayCollection();
  100.         $this->badges = new ArrayCollection();
  101.         $this->givenAnsweres = new ArrayCollection();
  102.         $this->sendMessages = new ArrayCollection();
  103.         $this->reveivedMessages = new ArrayCollection();
  104.         $this->billingAdress = new Adress();
  105.         $this->bookings = new ArrayCollection();
  106.         $this->licenseStatuses = new ArrayCollection();
  107.         $this->certificates = new ArrayCollection();
  108.         $this->loggedTimes = new ArrayCollection();
  109.         $this->lastLogin = new \DateTimeImmutable();
  110.     }
  112.     public function getEmail(): ?string
  113.     {
  114.         return $this->getUserInformation()->getEmail();
  115.     }
  117.     public function getId(): ?int
  118.     {
  119.         return $this->id;
  120.     }
  122.     public function __toString(): string
  123.     {
  124.         return $this->getUserInformation()->getFirstName() . ' ' . $this->getUserInformation()->getLastName();
  125.     }
  127.     public function getUsername(): ?string
  128.     {
  129.         return $this->username;
  130.     }
  132.     public function setUsername(string $username): self
  133.     {
  134.         $this->username = $username;
  136.         return $this;
  137.     }
  139.     /**
  140.      * A visual identifier that represents this user.
  141.      *
  142.      * @see UserInterface
  143.      */
  144.     public function getUserIdentifier(): string
  145.     {
  146.         return (string)$this->username;
  147.     }
  149.     /**
  150.      * @see UserInterface
  151.      */
  152.     public function getRoles(): array
  153.     {
  154.         $roles = $this->roles;
  155.         // guarantee every user at least has ROLE_USER
  156.         $roles[] = 'ROLE_USER';
  158.         return array_unique($roles);
  159.     }
  161.     public function setRoles(array $roles): self
  162.     {
  163.         $this->roles = $roles;
  165.         return $this;
  166.     }
  168.     /**
  169.      * @see PasswordAuthenticatedUserInterface
  170.      */
  171.     public function getPassword(): string
  172.     {
  173.         return $this->password;
  174.     }
  176.     public function setPassword(string $password): self
  177.     {
  178.         $this->password = $password;
  180.         return $this;
  181.     }
  183.     /**
  184.      * @see UserInterface
  185.      */
  186.     public function eraseCredentials()
  187.     {
  188.         // If you store any temporary, sensitive data on the user, clear it here
  189.         // $this->plainPassword = null;
  190.     }
  192.     public function getUserInformation(): UserInformation
  193.     {
  194.         return $this->userInformation;
  195.     }
  197.     public function setUserInformation(UserInformation $userInformation): self
  198.     {
  199.         $this->userInformation = $userInformation;
  200.         return $this;
  201.     }
  203.     public function getCorporation(): ?Corporation
  204.     {
  205.         return $this->corporation;
  206.     }
  208.     public function setCorporation(?Corporation $corporation): self
  209.     {
  210.         $this->corporation = $corporation;
  212.         return $this;
  213.     }
  215.     /**
  216.      * @return Collection<int, Course>
  217.      */
  218.     public function getCourses(): Collection
  219.     {
  220.         return $this->courses;
  221.     }
  223.     public function addCourse(Course $course): self
  224.     {
  225.         if (!$this->courses->contains($course)) {
  226.             $this->courses->add($course);
  227.             $course->addAttendee($this);
  228.         }
  230.         return $this;
  231.     }
  233.     public function removeCourse(Course $course): self
  234.     {
  235.         if ($this->courses->removeElement($course)) {
  236.             $course->removeAttendee($this);
  237.         }
  239.         return $this;
  240.     }
  242.     /**
  243.      * @return Collection<int, LessonProgress>
  244.      */
  245.     public function getLessonProgress(): Collection
  246.     {
  247.         return $this->lessonProgress;
  248.     }
  250.     public function addLessonProgress(LessonProgress $lessonProgress): self
  251.     {
  252.         if (!$this->lessonProgress->contains($lessonProgress)) {
  253.             $this->lessonProgress->add($lessonProgress);
  254.             $lessonProgress->setAttendee($this);
  255.         }
  257.         return $this;
  258.     }
  260.     public function removeLessonProgress(LessonProgress $lessonProgress): self
  261.     {
  262.         if ($this->lessonProgress->removeElement($lessonProgress)) {
  263.             // set the owning side to null (unless already changed)
  264.             if ($lessonProgress->getAttendee() === $this) {
  265.                 $lessonProgress->setAttendee(null);
  266.             }
  267.         }
  269.         return $this;
  270.     }
  272.     public function getPortal(): ?Portal
  273.     {
  274.         return $this->portal;
  275.     }
  277.     public function setPortal(?Portal $portal): self
  278.     {
  279.         $this->portal = $portal;
  281.         return $this;
  282.     }
  284.     /**
  285.      * @return Collection<int, CourseEvaluation>
  286.      */
  287.     public function getCourseEvaluations(): Collection
  288.     {
  289.         return $this->courseEvaluations;
  290.     }
  292.     public function addCourseEvaluation(CourseEvaluation $courseEvaluation): self
  293.     {
  294.         if (!$this->courseEvaluations->contains($courseEvaluation)) {
  295.             $this->courseEvaluations->add($courseEvaluation);
  296.             $courseEvaluation->setAttendee($this);
  297.         }
  299.         return $this;
  300.     }
  302.     public function removeCourseEvaluation(CourseEvaluation $courseEvaluation): self
  303.     {
  304.         if ($this->courseEvaluations->removeElement($courseEvaluation)) {
  305.             // set the owning side to null (unless already changed)
  306.             if ($courseEvaluation->getAttendee() === $this) {
  307.                 $courseEvaluation->setAttendee(null);
  308.             }
  309.         }
  311.         return $this;
  312.     }
  314.     /**
  315.      * @return Collection<int, Badge>
  316.      */
  317.     public function getBadges(): Collection
  318.     {
  319.         return $this->badges;
  320.     }
  322.     public function addBadge(Badge $badge): self
  323.     {
  324.         if (!$this->badges->contains($badge)) {
  325.             $this->badges->add($badge);
  326.         }
  328.         return $this;
  329.     }
  331.     public function removeBadge(Badge $badge): self
  332.     {
  333.         $this->badges->removeElement($badge);
  335.         return $this;
  336.     }
  338.     public function getMood(): ?int
  339.     {
  340.         return $this->mood;
  341.     }
  343.     public function setMood(int $mood): self
  344.     {
  345.         $this->mood = $mood;
  347.         return $this;
  348.     }
  350.     /**
  351.      * @return Collection<int, GivenAnswere>
  352.      */
  353.     public function getGivenAnsweres(): Collection
  354.     {
  355.         return $this->givenAnsweres;
  356.     }
  358.     public function addGivenAnswere(GivenAnswere $givenAnswere): self
  359.     {
  360.         if (!$this->givenAnsweres->contains($givenAnswere)) {
  361.             $this->givenAnsweres->add($givenAnswere);
  362.             $givenAnswere->setAttendee($this);
  363.         }
  365.         return $this;
  366.     }
  368.     public function removeGivenAnswere(GivenAnswere $givenAnswere): self
  369.     {
  370.         if ($this->givenAnsweres->removeElement($givenAnswere)) {
  371.             // set the owning side to null (unless already changed)
  372.             if ($givenAnswere->getAttendee() === $this) {
  373.                 $givenAnswere->setAttendee(null);
  374.             }
  375.         }
  377.         return $this;
  378.     }
  380.     /**
  381.      * @return Collection<int, Message>
  382.      */
  383.     public function getSendMessages(): Collection
  384.     {
  385.         return $this->sendMessages;
  386.     }
  388.     public function addSendMessage(Message $sendMessage): self
  389.     {
  390.         if (!$this->sendMessages->contains($sendMessage)) {
  391.             $this->sendMessages->add($sendMessage);
  392.             $sendMessage->setSender($this);
  393.         }
  395.         return $this;
  396.     }
  398.     public function removeSendMessage(Message $sendMessage): self
  399.     {
  400.         if ($this->sendMessages->removeElement($sendMessage)) {
  401.             // set the owning side to null (unless already changed)
  402.             if ($sendMessage->getSender() === $this) {
  403.                 $sendMessage->setSender(null);
  404.             }
  405.         }
  407.         return $this;
  408.     }
  410.     /**
  411.      * @return Collection<int, Message>
  412.      */
  413.     public function getReveivedMessages(): Collection
  414.     {
  415.         return $this->reveivedMessages;
  416.     }
  418.     public function addReveivedMessage(Message $reveivedMessage): self
  419.     {
  420.         if (!$this->reveivedMessages->contains($reveivedMessage)) {
  421.             $this->reveivedMessages->add($reveivedMessage);
  422.             $reveivedMessage->setReceiver($this);
  423.         }
  425.         return $this;
  426.     }
  428.     public function removeReveivedMessage(Message $reveivedMessage): self
  429.     {
  430.         if ($this->reveivedMessages->removeElement($reveivedMessage)) {
  431.             // set the owning side to null (unless already changed)
  432.             if ($reveivedMessage->getReceiver() === $this) {
  433.                 $reveivedMessage->setReceiver(null);
  434.             }
  435.         }
  437.         return $this;
  438.     }
  440.     public function isVerified(): bool
  441.     {
  442.         return $this->isVerified;
  443.     }
  445.     public function setIsVerified(bool $isVerified): self
  446.     {
  447.         $this->isVerified = $isVerified;
  449.         return $this;
  450.     }
  452.     public function getBillingAdress(): Adress
  453.     {
  454.         return $this->billingAdress;
  455.     }
  457.     public function setBillingAdress(Adress $billingadress): self
  458.     {
  459.         $this->billingAdress = $billingadress;
  460.         return $this;
  461.     }
  463.     /**
  464.      * @return Collection<int, Booking>
  465.      */
  466.     public function getBookings(): Collection
  467.     {
  468.         return $this->bookings;
  469.     }
  471.     public function addBooking(Booking $booking): self
  472.     {
  473.         if (!$this->bookings->contains($booking)) {
  474.             $this->bookings->add($booking);
  475.             $booking->setAttendee($this);
  476.         }
  478.         return $this;
  479.     }
  481.     public function removeBooking(Booking $booking): self
  482.     {
  483.         if ($this->bookings->removeElement($booking)) {
  484.             // set the owning side to null (unless already changed)
  485.             if ($booking->getAttendee() === $this) {
  486.                 $booking->setAttendee(null);
  487.             }
  488.         }
  490.         return $this;
  491.     }
  493.     /**
  494.      * @return Collection<int, LicenseStatus>
  495.      */
  496.     public function getLicenseStatuses(): Collection
  497.     {
  498.         return $this->licenseStatuses;
  499.     }
  501.     public function addLicenseStatus(LicenseStatus $licenseStatus): self
  502.     {
  503.         if (!$this->licenseStatuses->contains($licenseStatus)) {
  504.             $this->licenseStatuses->add($licenseStatus);
  505.             $licenseStatus->setAttendee($this);
  506.         }
  508.         return $this;
  509.     }
  511.     public function removeLicenseStatus(LicenseStatus $licenseStatus): self
  512.     {
  513.         if ($this->licenseStatuses->removeElement($licenseStatus)) {
  514.             // set the owning side to null (unless already changed)
  515.             if ($licenseStatus->getAttendee() === $this) {
  516.                 $licenseStatus->setAttendee(null);
  517.             }
  518.         }
  520.         return $this;
  521.     }
  523.     /**
  524.      * @return Collection<int, Certificate>
  525.      */
  526.     public function getCertificates(): Collection
  527.     {
  528.         return $this->certificates;
  529.     }
  531.     public function addCertificate(Certificate $certificate): self
  532.     {
  533.         if (!$this->certificates->contains($certificate)) {
  534.             $this->certificates->add($certificate);
  535.             $certificate->setAttendee($this);
  536.         }
  538.         return $this;
  539.     }
  541.     public function removeCertificate(Certificate $certificate): self
  542.     {
  543.         if ($this->certificates->removeElement($certificate)) {
  544.             // set the owning side to null (unless already changed)
  545.             if ($certificate->getAttendee() === $this) {
  546.                 $certificate->setAttendee(null);
  547.             }
  548.         }
  550.         return $this;
  551.     }
  553.     /**
  554.      * @return Collection<int, LoggedTime>
  555.      */
  556.     public function getLoggedTimes(): Collection
  557.     {
  558.         return $this->loggedTimes;
  559.     }
  561.     public function addLoggedTime(LoggedTime $loggedTime): self
  562.     {
  563.         if (!$this->loggedTimes->contains($loggedTime)) {
  564.             $this->loggedTimes->add($loggedTime);
  565.             $loggedTime->setAttendee($this);
  566.         }
  568.         return $this;
  569.     }
  571.     public function removeLoggedTime(LoggedTime $loggedTime): self
  572.     {
  573.         if ($this->loggedTimes->removeElement($loggedTime)) {
  574.             // set the owning side to null (unless already changed)
  575.             if ($loggedTime->getAttendee() === $this) {
  576.                 $loggedTime->setAttendee(null);
  577.             }
  578.         }
  580.         return $this;
  581.     }
  583.     public function getLastLogin(): ?\DateTimeInterface
  584.     {
  585.         return $this->lastLogin;
  586.     }
  588.     public function setLastLogin(\DateTimeInterface $lastLogin): self
  589.     {
  590.         $this->lastLogin = $lastLogin;
  592.         return $this;
  593.     }
  594. }