src/Entity/User.php line 19

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  10. use Symfony\Component\Security\Core\User\UserInterface;
  11. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  12. use Symfony\Component\HttpFoundation\File\File;
  14. #[ORM\Entity(repositoryClass: UserRepository::class)]
  15. #[ORM\InheritanceType('JOINED')]
  16. #[ORM\DiscriminatorColumn(name: "type", type: "string")]
  17. #[ORM\DiscriminatorMap(['commercial' => Commercial::class, 'prescriber' => Prescriber::class, 'employee' => Employee::class])]
  18. #[Vich\Uploadable]
  19. abstract class User implements UserInterface, PasswordAuthenticatedUserInterface
  20. {
  22.     use IdentifiableTrait;
  24.     #[ORM\Column(length: 180, unique: true)]
  25.     private ?string $username = null;
  27.     #[ORM\Column]
  28.     protected array $roles = [];
  30.     /**
  31.      * @var string|null The hashed password
  32.      */
  33.     #[ORM\Column]
  34.     private ?string $password = null;
  36.     #[ORM\Column(length: 255, nullable: true)]
  37.     private ?string $email = null;
  39.     #[ORM\OneToMany(mappedBy: 'prescriberValidationUser', targetEntity: Invoice::class)]
  40.     private Collection $prescriberValidatedInvoices;
  42.     #[ORM\OneToMany(mappedBy: 'origin', targetEntity: PrescriberPoint::class)]
  43.     private Collection $prescriberPoints;
  45.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: LogHistory::class)]
  46.     private Collection $logHistory;
  48.     #[ORM\Column(nullable: true)]
  49.     private ?bool $active = null;
  51.     #[ORM\Column(nullable: true)]
  52.     private ?\DateTimeImmutable $lastConnexionDate = null;
  54.     #[ORM\OneToMany(mappedBy: 'sender', targetEntity: Message::class, orphanRemoval: true)]
  55.     private Collection $senderMessages;
  57.     #[ORM\ManyToMany(targetEntity: MessageReceiver::class, mappedBy: 'users')]
  58.     private Collection $messageReceivers;
  60.     #[ORM\Column(type: "string", length: 255, nullable: true)]
  61.     private ?string $photoFilename = '';
  63.     #[Vich\UploadableField(mapping: "user_photo", fileNameProperty: "photoFilename")]
  64.     private ?File $photoFile = null;
  66.     #[ORM\OneToMany(mappedBy: 'targetUser', targetEntity: LogHistory::class)]
  67.     private Collection $logHistories;
  69.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Booking::class)]
  70.     private Collection $bookings;
  72.     #[ORM\OneToMany(mappedBy: 'attributedTo', targetEntity: PrescriptionPad::class)]
  73.     private Collection $prescriptionPads;
  75.     #[ORM\ManyToMany(targetEntity: BookingUserGroup::class, mappedBy: 'user')]
  76.     private Collection $bookingUserGroups;
  78.     #[ORM\ManyToMany(targetEntity: BookingEvent::class, mappedBy: 'users')]
  79.     private Collection $bookingEvents;
  82.     public function __construct()
  83.     {
  84.         $this->prescriberValidatedInvoices = new ArrayCollection();
  85.         $this->prescriberPoints            = new ArrayCollection();
  86.         $this->logHistory                  = new ArrayCollection();
  87.         $this->senderMessages              = new ArrayCollection();
  88.         $this->messageReceivers            = new ArrayCollection();
  89.         $this->logHistories                = new ArrayCollection();
  90.         $this->bookings                    = new ArrayCollection();
  91.         $this->prescriptionPads            = new ArrayCollection();
  92.         $this->bookingUserGroups           = new ArrayCollection();
  93.         $this->bookingEvents               = new ArrayCollection();
  94.     }
  96.     public function getId(): ?int
  97.     {
  98.         return $this->id;
  99.     }
  101.     /**
  102.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  103.      */
  104.     public function getUsername(): string
  105.     {
  106.         return (string)$this->username;
  107.     }
  110.     public function getFullName(): ?string
  111.     {
  112.         return (string)$this->username;
  113.     }
  116.     public function setUsername(string $username): self
  117.     {
  119.         $this->username = strtolower($username);
  121.         return $this;
  122.     }
  124.     /**
  125.      * A visual identifier that represents this user.
  126.      *
  127.      * @see UserInterface
  128.      */
  129.     public function getUserIdentifier(): string
  130.     {
  131.         return (string)$this->username;
  132.     }
  134.     /**
  135.      * @see UserInterface
  136.      */
  137.     public function getRoles(): array
  138.     {
  139.         $roles = $this->roles;
  140.         // guarantee every user at least has ROLE_USER
  141.         $roles[] = 'ROLE_USER';
  143.         return array_unique($roles);
  144.     }
  146.     public function setRoles(array $roles): self
  147.     {
  148.         $this->roles = $roles;
  150.         return $this;
  151.     }
  153.     public function hasRole(string $role): bool
  154.     {
  155.         return in_array($role, $this->roles, true);
  156.     }
  159.     /**
  160.      * @see PasswordAuthenticatedUserInterface
  161.      */
  162.     public function getPassword(): string
  163.     {
  164.         return $this->password;
  165.     }
  167.     public function setPassword(string $password): self
  168.     {
  169.         $this->password = $password;
  171.         return $this;
  172.     }
  174.     /**
  175.      * Returning a salt is only needed, if you are not using a modern
  176.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  177.      *
  178.      * @see UserInterface
  179.      */
  180.     public function getSalt(): ?string
  181.     {
  182.         return null;
  183.     }
  185.     /**
  186.      * @see UserInterface
  187.      */
  188.     public function eraseCredentials()
  189.     {
  190.         // If you store any temporary, sensitive data on the user, clear it here
  191.         // $this->plainPassword = null;
  192.     }
  194.     public function getEmail(): ?string
  195.     {
  196.         return $this->email;
  197.     }
  199.     public function setEmail(?string $email): self
  200.     {
  201.         $this->email = strtolower($email);
  203.         return $this;
  204.     }
  206.     /**
  207.      * @return Collection<int, Invoice>
  208.      */
  209.     public function getPrescriberValidatedInvoices(): Collection
  210.     {
  211.         return $this->prescriberValidatedInvoices;
  212.     }
  214.     public function addPrescriberValidatedInvoice(Invoice $prescriberValidatedInvoice): self
  215.     {
  216.         if (!$this->prescriberValidatedInvoices->contains($prescriberValidatedInvoice)) {
  217.             $this->prescriberValidatedInvoices->add($prescriberValidatedInvoice);
  218.             $prescriberValidatedInvoice->setPrescriberValidationUser($this);
  219.         }
  221.         return $this;
  222.     }
  224.     public function removePrescriberValidatedInvoice(Invoice $prescriberValidatedInvoice): self
  225.     {
  226.         if ($this->prescriberValidatedInvoices->removeElement($prescriberValidatedInvoice)) {
  227.             // set the owning side to null (unless already changed)
  228.             if ($prescriberValidatedInvoice->getPrescriberValidationUser() === $this) {
  229.                 $prescriberValidatedInvoice->setPrescriberValidationUser(null);
  230.             }
  231.         }
  233.         return $this;
  234.     }
  236.     /**
  237.      * @return Collection<int, PrescriberPoint>
  238.      */
  239.     public function getPrescriberPoints(): Collection
  240.     {
  241.         return $this->prescriberPoints;
  242.     }
  244.     public function addPrescriberPoint(PrescriberPoint $prescriberPoint): self
  245.     {
  246.         if (!$this->prescriberPoints->contains($prescriberPoint)) {
  247.             $this->prescriberPoints->add($prescriberPoint);
  248.             $prescriberPoint->setOrigin($this);
  249.         }
  251.         return $this;
  252.     }
  254.     public function removePrescriberPoint(PrescriberPoint $prescriberPoint): self
  255.     {
  256.         if ($this->prescriberPoints->removeElement($prescriberPoint)) {
  257.             // set the owning side to null (unless already changed)
  258.             if ($prescriberPoint->getOrigin() === $this) {
  259.                 $prescriberPoint->setOrigin(null);
  260.             }
  261.         }
  263.         return $this;
  264.     }
  266.     /**
  267.      * @return Collection<int, LogHistory>
  268.      */
  269.     public function getLogHistory(): Collection
  270.     {
  271.         return $this->logHistory;
  272.     }
  274.     public function addLogHistory(LogHistory $logHistory): self
  275.     {
  276.         if (!$this->logHistory->contains($logHistory)) {
  277.             $this->logHistory->add($logHistory);
  278.             $logHistory->setUser($this);
  279.         }
  281.         return $this;
  282.     }
  284.     public function removeLogHistory(LogHistory $logHistory): self
  285.     {
  286.         if ($this->logHistory->removeElement($logHistory)) {
  287.             // set the owning side to null (unless already changed)
  288.             if ($logHistory->getUser() === $this) {
  289.                 $logHistory->setUser(null);
  290.             }
  291.         }
  293.         return $this;
  294.     }
  296.     public function isActive(): ?bool
  297.     {
  298.         return $this->active;
  299.     }
  301.     public function setActive(?bool $active): self
  302.     {
  303.         $this->active = $active;
  305.         return $this;
  306.     }
  308.     public function getLastConnexionDate(): ?\DateTimeImmutable
  309.     {
  310.         return $this->lastConnexionDate;
  311.     }
  313.     public function setLastConnexionDate(?\DateTimeImmutable $lastConnexionDate): self
  314.     {
  315.         $this->lastConnexionDate = $lastConnexionDate;
  317.         return $this;
  318.     }
  320.     /**
  321.      * @return Collection<int, Message>
  322.      */
  323.     public function getSenderMessages(): Collection
  324.     {
  325.         return $this->senderMessages;
  326.     }
  328.     public function addSenderMessage(Message $senderMessage): self
  329.     {
  330.         if (!$this->senderMessages->contains($senderMessage)) {
  331.             $this->senderMessages->add($senderMessage);
  332.             $senderMessage->setSender($this);
  333.         }
  335.         return $this;
  336.     }
  338.     public function removeSenderMessage(Message $senderMessage): self
  339.     {
  340.         if ($this->senderMessages->removeElement($senderMessage)) {
  341.             // set the owning side to null (unless already changed)
  342.             if ($senderMessage->getSender() === $this) {
  343.                 $senderMessage->setSender(null);
  344.             }
  345.         }
  347.         return $this;
  348.     }
  350.     /**
  351.      * @return Collection<int, MessageReceiver>
  352.      */
  353.     public function getMessageReceivers(): Collection
  354.     {
  355.         return $this->messageReceivers;
  356.     }
  358.     public function addMessageReceiver(MessageReceiver $messageReceiver): self
  359.     {
  360.         if (!$this->messageReceivers->contains($messageReceiver)) {
  361.             $this->messageReceivers->add($messageReceiver);
  362.             $messageReceiver->addUser($this);
  363.         }
  365.         return $this;
  366.     }
  368.     public function removeMessageReceiver(MessageReceiver $messageReceiver): self
  369.     {
  370.         if ($this->messageReceivers->removeElement($messageReceiver)) {
  371.             $messageReceiver->removeUser($this);
  372.         }
  374.         return $this;
  375.     }
  378.     public function getPhotoFilename(): ?string
  379.     {
  380.         return $this->photoFilename;
  381.     }
  383.     public function setPhotoFilename(?string $photoFilename): self
  384.     {
  385.         $this->photoFilename = $photoFilename;
  386.         return $this;
  387.     }
  389.     public function getPhotoFile(): ?File
  390.     {
  391.         return $this->photoFile;
  392.     }
  394.     public function setPhotoFile(?File $photoFile): self
  395.     {
  396.         $this->photoFile = $photoFile;
  398.         if (null !== $photoFile) {
  399.             // Ceci est nécessaire pour forcer la mise à jour de l'entité lorsque le fichier est modifié
  400.             $this->updatedAt = new \DateTimeImmutable();
  401.         }
  403.         return $this;
  404.     }
  406.     /**
  407.      * @return Collection<int, LogHistory>
  408.      */
  409.     public function getLogHistories(): Collection
  410.     {
  411.         return $this->logHistories;
  412.     }
  414.     /**
  415.      * @return Collection<int, Booking>
  416.      */
  417.     public function getBookings(): Collection
  418.     {
  419.         return $this->bookings;
  420.     }
  422.     public function addBooking(Booking $booking): static
  423.     {
  424.         if (!$this->bookings->contains($booking)) {
  425.             $this->bookings->add($booking);
  426.             $booking->setOwner($this);
  427.         }
  429.         return $this;
  430.     }
  432.     public function removeBooking(Booking $booking): static
  433.     {
  434.         if ($this->bookings->removeElement($booking)) {
  435.             // set the owning side to null (unless already changed)
  436.             if ($booking->getOwner() === $this) {
  437.                 $booking->setOwner(null);
  438.             }
  439.         }
  441.         return $this;
  442.     }
  444.     /**
  445.      * @return Collection<int, PrescriptionPad>
  446.      */
  447.     public function getPrescriptionPads(): Collection
  448.     {
  449.         return $this->prescriptionPads;
  450.     }
  452.     public function addPrescriptionPad(PrescriptionPad $prescriptionPad): static
  453.     {
  454.         if (!$this->prescriptionPads->contains($prescriptionPad)) {
  455.             $this->prescriptionPads->add($prescriptionPad);
  456.             $prescriptionPad->setAttributedTo($this);
  457.         }
  459.         return $this;
  460.     }
  462.     public function removePrescriptionPad(PrescriptionPad $prescriptionPad): static
  463.     {
  464.         if ($this->prescriptionPads->removeElement($prescriptionPad)) {
  465.             // set the owning side to null (unless already changed)
  466.             if ($prescriptionPad->getAttributedTo() === $this) {
  467.                 $prescriptionPad->setAttributedTo(null);
  468.             }
  469.         }
  471.         return $this;
  472.     }
  474.     /**
  475.      * @return Collection<int, BookingUserGroup>
  476.      */
  477.     public function getBookingUserGroups(): Collection
  478.     {
  479.         return $this->bookingUserGroups;
  480.     }
  482.     public function addBookingUserGroup(BookingUserGroup $bookingUserGroup): static
  483.     {
  484.         if (!$this->bookingUserGroups->contains($bookingUserGroup)) {
  485.             $this->bookingUserGroups->add($bookingUserGroup);
  486.             $bookingUserGroup->addUser($this);
  487.         }
  489.         return $this;
  490.     }
  492.     public function removeBookingUserGroup(BookingUserGroup $bookingUserGroup): static
  493.     {
  494.         if ($this->bookingUserGroups->removeElement($bookingUserGroup)) {
  495.             $bookingUserGroup->removeUser($this);
  496.         }
  498.         return $this;
  499.     }
  501.     /**
  502.      * @return Collection<int, BookingEvent>
  503.      */
  504.     public function getPrescriberSpeakersBookingEvents(): Collection
  505.     {
  506.         return $this->bookingEvents;
  507.     }
  509.     public function addBookingEvent(BookingEvent $bookingEvent): static
  510.     {
  511.         if (!$this->bookingEvents->contains($bookingEvent)) {
  512.             $this->bookingEvents->add($bookingEvent);
  513.             $bookingEvent->addUser($this);
  514.         }
  516.         return $this;
  517.     }
  519.     public function removeBookingEvent(BookingEvent $bookingEvent): static
  520.     {
  521.         if ($this->bookingEvents->removeElement($bookingEvent)) {
  522.             $bookingEvent->removeUser($this);
  523.         }
  525.         return $this;
  526.     }
  529. }