src/Entity/User.php line 14

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 Doctrine\ORM\Mapping\JoinTable;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  13. #[ORM\Entity(repositoryClass: UserRepository::class)]
  14. class User implements UserInterface, PasswordAuthenticatedUserInterface
  15. {
  16.     #[ORM\Id]
  17.     #[ORM\GeneratedValue]
  18.     #[ORM\Column]
  19.     private ?int $id = null;
  21.     #[ORM\Column(length: 180, unique: true)]
  22.     private ?string $email = null;
  24.     #[ORM\Column]
  25.     private array $roles = [];
  27.     /**
  28.      * @var string The hashed password
  29.      */
  30.     #[ORM\Column]
  31.     private ?string $password = null;
  33.     #[ORM\Column(length: 100)]
  34.     private ?string $name = null;
  36.     #[ORM\Column(length: 200)]
  37.     private ?string $firstname = null;
  39.     #[ORM\Column(length: 255, nullable: true)]
  40.     private ?string $logo = null;
  42.     #[ORM\Column]
  43.     private ?\DateTimeImmutable $createdAt = null;
  45.     #[ORM\Column(nullable: true)]
  46.     private ?\DateTimeImmutable $updatedAt = null;
  48.     #[ORM\ManyToOne(inversedBy: 'users')]
  49.     private ?Company $company = null;
  51.     #[ORM\ManyToMany(targetEntity: Project::class, mappedBy: 'user')]
  52.     #[ORM\OrderBy(["id"=>'DESC'])]
  53.     private Collection $projects;
  55.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Logs::class, cascade:['remove'])]
  56.     #[ORM\OrderBy(['id'=>'DESC'])]
  57.     private Collection $logs;
  59.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Notification::class, cascade:['remove'])]
  60.     private Collection $notifications;
  62.     #[ORM\ManyToMany(targetEntity: Project::class, mappedBy: 'admin')]
  63.     private Collection $adminProjects;
  65.     #[ORM\OneToOne(mappedBy: 'user', cascade: ['persist', 'remove'])]
  66.     private ?UpdatePassword $updatePassword = null;
  68.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ConnectionHistory::class, cascade:['remove'])]
  69.     private Collection $connectionHistories;
  71.     #[ORM\Column(nullable: true)]
  72.     private ?string $phone_number = null;
  74.     #[ORM\ManyToMany(targetEntity: Project::class, mappedBy: 'contact')]
  75.     private Collection $contact;
  77.     #[ORM\Column]
  78.     private ?bool $isPasswordChanged = null;
  80.     public function __construct()
  81.     {
  82.         $this->projects = new ArrayCollection();
  83.         $this->logs = new ArrayCollection();
  84.         $this->notifications = new ArrayCollection();
  85.         $this->adminProjects = new ArrayCollection();
  86.         $this->connectionHistories = new ArrayCollection();
  87.         $this->contact = new ArrayCollection();
  88.     }
  90.     public function getId(): ?int
  91.     {
  92.         return $this->id;
  93.     }
  95.     public function getEmail(): ?string
  96.     {
  97.         return $this->email;
  98.     }
  100.     public function setEmail(string $email): self
  101.     {
  102.         $this->email = $email;
  104.         return $this;
  105.     }
  107.     /**
  108.      * A visual identifier that represents this user.
  109.      *
  110.      * @see UserInterface
  111.      */
  112.     public function getUserIdentifier(): string
  113.     {
  114.         return (string) $this->email;
  115.     }
  117.     /**
  118.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  119.      */
  120.     public function getUsername(): string
  121.     {
  122.         return (string) $this->email;
  123.     }
  125.     /**
  126.      * @see UserInterface
  127.      */
  128.     public function getRoles(): array
  129.     {
  130.         $roles = $this->roles;
  131.         // guarantee every user at least has ROLE_USER
  133.         return array_unique($roles);
  134.     }
  136.     public function setRoles(array $roles): self
  137.     {
  138.         $this->roles = $roles;
  140.         return $this;
  141.     }
  143.     /**
  144.      * @see PasswordAuthenticatedUserInterface
  145.      */
  146.     public function getPassword(): string
  147.     {
  148.         return $this->password;
  149.     }
  151.     public function setPassword(string $password): self
  152.     {
  153.         $this->password = $password;
  155.         return $this;
  156.     }
  158.     /**
  159.      * Returning a salt is only needed, if you are not using a modern
  160.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  161.      *
  162.      * @see UserInterface
  163.      */
  164.     public function getSalt(): ?string
  165.     {
  166.         return null;
  167.     }
  169.     /**
  170.      * @see UserInterface
  171.      */
  172.     public function eraseCredentials()
  173.     {
  174.         // If you store any temporary, sensitive data on the user, clear it here
  175.         // $this->plainPassword = null;
  176.     }
  178.     public function getName(): ?string
  179.     {
  180.         return $this->name;
  181.     }
  183.     public function setName(string $name): self
  184.     {
  185.         $this->name = $name;
  187.         return $this;
  188.     }
  190.     public function getFirstname(): ?string
  191.     {
  192.         return $this->firstname;
  193.     }
  195.     public function setFirstname(string $firstname): self
  196.     {
  197.         $this->firstname = $firstname;
  199.         return $this;
  200.     }
  202.     public function getLogo(): ?string
  203.     {
  204.         return $this->logo;
  205.     }
  207.     public function setLogo(?string $logo): self
  208.     {
  209.         $this->logo = $logo;
  211.         return $this;
  212.     }
  214.     public function getCreatedAt(): ?\DateTimeImmutable
  215.     {
  216.         return $this->createdAt;
  217.     }
  219.     public function setCreatedAt(\DateTimeImmutable $createdAt): self
  220.     {
  221.         $this->createdAt = $createdAt;
  223.         return $this;
  224.     }
  226.     public function getUpdatedAt(): ?\DateTimeImmutable
  227.     {
  228.         return $this->updatedAt;
  229.     }
  231.     public function setUpdatedAt(?\DateTimeImmutable $updatedAt): self
  232.     {
  233.         $this->updatedAt = $updatedAt;
  235.         return $this;
  236.     }
  238.     public function __toString()
  239.     {
  240.         return $this->name . $this->firstname . '|';
  241.     }
  243.     public function getCompany(): ?Company
  244.     {
  245.         return $this->company;
  246.     }
  248.     public function setCompany(?Company $company): self
  249.     {
  250.         $this->company = $company;
  252.         return $this;
  253.     }
  255.     /**
  256.      * @return Collection<int, Project>
  257.      */
  258.     public function getProjects(): Collection
  259.     {
  260.         return $this->projects;
  261.     }
  263.     public function addProject(Project $project): self
  264.     {
  265.         if (!$this->projects->contains($project)) {
  266.             $this->projects->add($project);
  267.             $project->addUser($this);
  268.         }
  270.         return $this;
  271.     }
  273.     public function removeProject(Project $project): self
  274.     {
  275.         if ($this->projects->removeElement($project)) {
  276.             $project->removeUser($this);
  277.         }
  279.         return $this;
  280.     }
  282.     /**
  283.      * @return Collection<int, Logs>
  284.      */
  285.     public function getLogs(): Collection
  286.     {
  287.         return $this->logs;
  288.     }
  290.     public function addLog(Logs $log): self
  291.     {
  292.         if (!$this->logs->contains($log)) {
  293.             $this->logs->add($log);
  294.             $log->setUser($this);
  295.         }
  297.         return $this;
  298.     }
  300.     public function removeLog(Logs $log): self
  301.     {
  302.         if ($this->logs->removeElement($log)) {
  303.             // set the owning side to null (unless already changed)
  304.             if ($log->getUser() === $this) {
  305.                 $log->setUser(null);
  306.             }
  307.         }
  309.         return $this;
  310.     }
  312.     /**
  313.      * @return Collection<int, Notification>
  314.      */
  315.     public function getNotifications(): Collection
  316.     {
  317.         return $this->notifications;
  318.     }
  320.     public function addNotification(Notification $notification): self
  321.     {
  322.         if (!$this->notifications->contains($notification)) {
  323.             $this->notifications->add($notification);
  324.             $notification->setUser($this);
  325.         }
  327.         return $this;
  328.     }
  330.     public function removeNotification(Notification $notification): self
  331.     {
  332.         if ($this->notifications->removeElement($notification)) {
  333.             // set the owning side to null (unless already changed)
  334.             if ($notification->getUser() === $this) {
  335.                 $notification->setUser(null);
  336.             }
  337.         }
  339.         return $this;
  340.     }
  342.     /**
  343.      * @return Collection<int, Project>
  344.      */
  345.     public function getAdminProjects(): Collection
  346.     {
  347.         return $this->adminProjects;
  348.     }
  350.     public function addAdminProject(Project $adminProject): self
  351.     {
  352.         if (!$this->adminProjects->contains($adminProject)) {
  353.             $this->adminProjects->add($adminProject);
  354.             $adminProject->addAdmin($this);
  355.         }
  357.         return $this;
  358.     }
  360.     public function removeAdminProject(Project $adminProject): self
  361.     {
  362.         if ($this->adminProjects->removeElement($adminProject)) {
  363.             $adminProject->removeAdmin($this);
  364.         }
  366.         return $this;
  367.     }
  369.     public function getUpdatePassword(): ?UpdatePassword
  370.     {
  371.         return $this->updatePassword;
  372.     }
  374.     public function setUpdatePassword(UpdatePassword $updatePassword): self
  375.     {
  376.         // set the owning side of the relation if necessary
  377.         if ($updatePassword->getUser() !== $this) {
  378.             $updatePassword->setUser($this);
  379.         }
  381.         $this->updatePassword = $updatePassword;
  383.         return $this;
  384.     }
  386.     /**
  387.      * @return Collection<int, ConnectionHistory>
  388.      */
  389.     public function getConnectionHistories(): Collection
  390.     {
  391.         return $this->connectionHistories;
  392.     }
  394.     public function addConnectionHistory(ConnectionHistory $connectionHistory): self
  395.     {
  396.         if (!$this->connectionHistories->contains($connectionHistory)) {
  397.             $this->connectionHistories->add($connectionHistory);
  398.             $connectionHistory->setUser($this);
  399.         }
  401.         return $this;
  402.     }
  404.     public function removeConnectionHistory(ConnectionHistory $connectionHistory): self
  405.     {
  406.         if ($this->connectionHistories->removeElement($connectionHistory)) {
  407.             // set the owning side to null (unless already changed)
  408.             if ($connectionHistory->getUser() === $this) {
  409.                 $connectionHistory->setUser(null);
  410.             }
  411.         }
  413.         return $this;
  414.     }
  416.     public function getPhoneNumber(): ?string
  417.     {
  418.         return $this->phone_number;
  419.     }
  421.     public function setPhoneNumber(?string $phone_number): self
  422.     {
  423.         $this->phone_number = $phone_number;
  425.         return $this;
  426.     }
  428.     /**
  429.      * @return Collection<int, Project>
  430.      */
  431.     public function getContact(): Collection
  432.     {
  433.         return $this->contact;
  434.     }
  436.     public function addContact(Project $contact): self
  437.     {
  438.         if (!$this->contact->contains($contact)) {
  439.             $this->contact->add($contact);
  440.             $contact->addContact($this);
  441.         }
  443.         return $this;
  444.     }
  446.     public function removeContact(Project $contact): self
  447.     {
  448.         if ($this->contact->removeElement($contact)) {
  449.             $contact->removeContact($this);
  450.         }
  452.         return $this;
  453.     }
  455.     public function isIsPasswordChanged(): ?bool
  456.     {
  457.         return $this->isPasswordChanged;
  458.     }
  460.     public function setIsPasswordChanged(bool $isPasswordChanged): self
  461.     {
  462.         $this->isPasswordChanged = $isPasswordChanged;
  464.         return $this;
  465.     }
  466. }