src/Entity/User.php line 16

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Gedmo\Timestampable\Traits\TimestampableEntity;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  14. #[ORM\Entity(UserRepository::class)]
  15. #[ORM\Table('`user`')]
  16. class User implements UserInterface, PasswordAuthenticatedUserInterface
  17. {
  18.     use TimestampableEntity;
  20.     #[ORM\Id]
  21.     #[ORM\GeneratedValue]
  22.     #[ORM\Column]
  23.     private ?int $id;
  25.     #[ORM\Column(length: 180, nullable: true)]
  26.     private ?string $email;
  28.     #[ORM\Column(type: Types::JSON)]
  29.     private array $roles = [];
  31.     /**
  32.      * The hashed password
  33.      */
  34.     #[ORM\Column]
  35.     private ?string $password;
  37.     /**
  38.      * The plain non-persisted password
  39.      */
  40.     private ?string $plainPassword;
  42.     #[ORM\Column]
  43.     private bool $enabled = true;
  45.     #[ORM\Column]
  46.     private ?string $firstName;
  48.     #[ORM\Column]
  49.     private ?string $lastName;
  51.     #[ORM\Column(nullable: true)]
  52.     private ?string $avatar;
  54.     #[ORM\OneToMany('askedBy', Question::class)]
  55.     private Collection $questions;
  57.     #[ORM\OneToMany('answeredBy', Answer::class)]
  58.     private Collection $answers;
  60.     #[ORM\OneToMany(mappedBy: 'vergunning_medewerker', targetEntity: Order::class)]
  61.     private Collection $orders;
  63.     #[ORM\Column(length: 255)]
  64.     private ?string $username = null;
  66.     #[ORM\OneToMany(mappedBy: 'offerte_medewerker', targetEntity: Order::class)]
  67.     private Collection $orderss;
  69.     #[ORM\OneToMany(mappedBy: 'afhaler_contactmedewerker', targetEntity: Order::class)]
  70.     private Collection $orders_afhaler_contactmedewerker;
  72.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Reminder::class)]
  73.     private Collection $reminders;
  75.     #[ORM\ManyToMany(targetEntity: Groep::class, mappedBy: 'users')]
  76.     private Collection $groepen;
  78.     #[ORM\OneToMany(mappedBy: 'ingevoerd_door', targetEntity: Reminder::class)]
  79.     private Collection $created_reminders;
  81.     public function __construct()
  82.     {
  83.         $this->questions = new ArrayCollection();
  84.         $this->answers = new ArrayCollection();
  85.         $this->orders = new ArrayCollection();
  86.         $this->orderss = new ArrayCollection();
  87.         $this->orders_afhaler_contactmedewerker = new ArrayCollection();
  88.         $this->reminders = new ArrayCollection();
  89.         $this->groepen = new ArrayCollection();
  90.         $this->created_reminders = new ArrayCollection();
  91.     }
  93.     public function __toString()
  94.     {
  95.         return $this->getFullName();
  96.     }
  99.     public function getId(): ?int
  100.     {
  101.         return $this->id;
  102.     }
  104.     public function getEmail(): ?string
  105.     {
  106.         return $this->email;
  107.     }
  109.     public function setEmail(string $email): self
  110.     {
  111.         $this->email = $email;
  113.         return $this;
  114.     }
  116.     /**
  117.      * A visual identifier that represents this user.
  118.      *
  119.      * @see UserInterface
  120.      */
  121.     public function getUserIdentifier(): string
  122.     {
  123.         return (string) $this->username;
  124.     }
  126.     /**
  127.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  128.      */
  129.     public function getUsername(): string
  130.     {
  131.         return (string) $this->username;
  132.     }
  134.     public function getRoles(): array
  135.     {
  136.         return $this->roles;
  137.     }
  139.     public function setRoles(array $roles): self
  140.     {
  141.         $this->roles = $roles;
  143.         return $this;
  144.     }
  146.     public function getPassword(): ?string
  147.     {
  148.         return $this->password;
  149.     }
  151.     public function setPassword(string $password): self
  152.     {
  153.         $this->password = $password;
  154.         
  155.         return $this;
  156.     }
  158.     public function getPlainPassword(): string
  159.     {
  160.         return $this->plainPassword;
  161.     }
  162.    
  163.     public function issetPlainPassword(): bool
  164.     {
  165.         if(isset ($this->plainPassword)){
  166.             return true;
  167.         };
  168.         return false;
  169.     }
  170.     
  172.     public function setPlainPassword(string $plainPassword): void
  173.     {
  174.         $this->plainPassword = $plainPassword;
  175.     }
  177.     /**
  178.      * Returning a salt is only needed, if you are not using a modern
  179.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  180.      *
  181.      * @see UserInterface
  182.      */
  183.     public function getSalt(): ?string
  184.     {
  185.         return null;
  186.     }
  188.     /**
  189.      * @see UserInterface
  190.      */
  191.     public function eraseCredentials()
  192.     {
  193.         // If you store any temporary, sensitive data on the user, clear it here
  194.          $this->plainPassword = null;
  195.     }
  197.     public function isEnabled(): ?bool
  198.     {
  199.         return $this->enabled;
  200.     }
  202.     public function setEnabled(bool $enabled): self
  203.     {
  204.         $this->enabled = $enabled;
  206.         return $this;
  207.     }
  209.     public function getFirstName(): ?string
  210.     {
  211.         return $this->firstName;
  212.     }
  214.     public function setFirstName(string $firstName): self
  215.     {
  216.         $this->firstName = $firstName;
  218.         return $this;
  219.     }
  221.     public function getLastName(): ?string
  222.     {
  223.         return $this->lastName;
  224.     }
  226.     public function setLastName(string $lastName): self
  227.     {
  228.         $this->lastName = $lastName;
  230.         return $this;
  231.     }
  233.     public function getFullName(): ?string
  234.     {
  235.         return $this->firstName.' '.$this->lastName;
  236.     }
  238.     public function getAvatar(): ?string
  239.     {
  240.         return $this->avatar;
  241.     }
  243.     public function getAvatarUrl(): ?string
  244.     {
  245.         if (!$this->avatar) {
  246.             return null;
  247.         }
  249.         if (strpos($this->avatar, '/') !== false) {
  250.             return $this->avatar;
  251.         }
  253.         return sprintf('/uploads/avatars/%s', $this->avatar);
  254.     }
  256.     public function setAvatar(?string $avatar): self
  257.     {
  258.         $this->avatar = $avatar;
  260.         return $this;
  261.     }
  263.     /**
  264.      * @return Collection<int, Question>
  265.      */
  266.     public function getQuestions(): Collection
  267.     {
  268.         return $this->questions;
  269.     }
  271.     public function addQuestion(Question $question): self
  272.     {
  273.         if (!$this->questions->contains($question)) {
  274.             $this->questions->add($question);
  275.             $question->setAskedBy($this);
  276.         }
  278.         return $this;
  279.     }
  281.     public function removeQuestion(Question $question): self
  282.     {
  283.         if ($this->questions->removeElement($question)) {
  284.             // set the owning side to null (unless already changed)
  285.             if ($question->getAskedBy() === $this) {
  286.                 $question->setAskedBy(null);
  287.             }
  288.         }
  290.         return $this;
  291.     }
  293.     /**
  294.      * @return Collection<int, Answer>
  295.      */
  296.     public function getAnswers(): Collection
  297.     {
  298.         return $this->answers;
  299.     }
  301.     public function addAnswer(Answer $answer): self
  302.     {
  303.         if (!$this->answers->contains($answer)) {
  304.             $this->answers->add($answer);
  305.             $answer->setAnsweredBy($this);
  306.         }
  308.         return $this;
  309.     }
  311.     public function removeAnswer(Answer $answer): self
  312.     {
  313.         if ($this->answers->removeElement($answer)) {
  314.             // set the owning side to null (unless already changed)
  315.             if ($answer->getAnsweredBy() === $this) {
  316.                 $answer->setAnsweredBy(null);
  317.             }
  318.         }
  320.         return $this;
  321.     }
  323.     /**
  324.      * @return Collection<int, Order>
  325.      */
  326.     public function getOrders(): Collection
  327.     {
  328.         return $this->orders;
  329.     }
  331.     public function addOrder(Order $order): self
  332.     {
  333.         if (!$this->orders->contains($order)) {
  334.             $this->orders->add($order);
  335.             $order->setVergunningMedewerker($this);
  336.         }
  338.         return $this;
  339.     }
  341.     public function removeOrder(Order $order): self
  342.     {
  343.         if ($this->orders->removeElement($order)) {
  344.             // set the owning side to null (unless already changed)
  345.             if ($order->getVergunningMedewerker() === $this) {
  346.                 $order->setVergunningMedewerker(null);
  347.             }
  348.         }
  350.         return $this;
  351.     }
  353.     public function setUsername(string $username): self
  354.     {
  355.         $this->username = $username;
  357.         return $this;
  358.     }
  360.     /**
  361.      * @return Collection<int, Order>
  362.      */
  363.     public function getOrderss(): Collection
  364.     {
  365.         return $this->orderss;
  366.     }
  368.     public function addOrderss(Order $orderss): self
  369.     {
  370.         if (!$this->orderss->contains($orderss)) {
  371.             $this->orderss->add($orderss);
  372.             $orderss->setOfferteMedewerker($this);
  373.         }
  375.         return $this;
  376.     }
  378.     public function removeOrderss(Order $orderss): self
  379.     {
  380.         if ($this->orderss->removeElement($orderss)) {
  381.             // set the owning side to null (unless already changed)
  382.             if ($orderss->getOfferteMedewerker() === $this) {
  383.                 $orderss->setOfferteMedewerker(null);
  384.             }
  385.         }
  387.         return $this;
  388.     }
  390.     /**
  391.      * @return Collection<int, Order>
  392.      */
  393.     public function getOrdersAfhalerContactmedewerker(): Collection
  394.     {
  395.         return $this->orders_afhaler_contactmedewerker;
  396.     }
  398.     public function addOrdersAfhalerContactmedewerker(Order $ordersAfhalerContactmedewerker): self
  399.     {
  400.         if (!$this->orders_afhaler_contactmedewerker->contains($ordersAfhalerContactmedewerker)) {
  401.             $this->orders_afhaler_contactmedewerker->add($ordersAfhalerContactmedewerker);
  402.             $ordersAfhalerContactmedewerker->setAfhalerContactmedewerker($this);
  403.         }
  405.         return $this;
  406.     }
  408.     public function removeOrdersAfhalerContactmedewerker(Order $ordersAfhalerContactmedewerker): self
  409.     {
  410.         if ($this->orders_afhaler_contactmedewerker->removeElement($ordersAfhalerContactmedewerker)) {
  411.             // set the owning side to null (unless already changed)
  412.             if ($ordersAfhalerContactmedewerker->getAfhalerContactmedewerker() === $this) {
  413.                 $ordersAfhalerContactmedewerker->setAfhalerContactmedewerker(null);
  414.             }
  415.         }
  417.         return $this;
  418.     }
  420.     /**
  421.      * @return Collection<int, Reminder>
  422.      */
  423.     public function getReminders(): Collection
  424.     {
  425.         return $this->reminders;
  426.     }
  428.     public function addReminder(Reminder $reminder): self
  429.     {
  430.         if (!$this->reminders->contains($reminder)) {
  431.             $this->reminders->add($reminder);
  432.             $reminder->setUser($this);
  433.         }
  435.         return $this;
  436.     }
  438.     public function removeReminder(Reminder $reminder): self
  439.     {
  440.         if ($this->reminders->removeElement($reminder)) {
  441.             // set the owning side to null (unless already changed)
  442.             if ($reminder->getUser() === $this) {
  443.                 $reminder->setUser(null);
  444.             }
  445.         }
  447.         return $this;
  448.     }
  450.     /**
  451.      * @return Collection<int, Groep>
  452.      */
  453.     public function getGroepen(): Collection
  454.     {
  455.         return $this->groepen;
  456.     }
  458.     public function addGroepen(Groep $groepen): static
  459.     {
  460.         if (!$this->groepen->contains($groepen)) {
  461.             $this->groepen->add($groepen);
  462.             $groepen->addUser($this);
  463.         }
  465.         return $this;
  466.     }
  468.     public function removeGroepen(Groep $groepen): static
  469.     {
  470.         if ($this->groepen->removeElement($groepen)) {
  471.             $groepen->removeUser($this);
  472.         }
  474.         return $this;
  475.     }
  477.     /**
  478.      * @return Collection<int, Reminder>
  479.      */
  480.     public function getCreatedReminders(): Collection
  481.     {
  482.         return $this->created_reminders;
  483.     }
  485.     public function addCreatedReminder(Reminder $createdReminder): static
  486.     {
  487.         if (!$this->created_reminders->contains($createdReminder)) {
  488.             $this->created_reminders->add($createdReminder);
  489.             $createdReminder->setIngevoerdDoor($this);
  490.         }
  492.         return $this;
  493.     }
  495.     public function removeCreatedReminder(Reminder $createdReminder): static
  496.     {
  497.         if ($this->created_reminders->removeElement($createdReminder)) {
  498.             // set the owning side to null (unless already changed)
  499.             if ($createdReminder->getIngevoerdDoor() === $this) {
  500.                 $createdReminder->setIngevoerdDoor(null);
  501.             }
  502.         }
  504.         return $this;
  505.     }
  510. }