src/Entity/User.php line 20

  1. <?php
  3. namespace App\Entity;
  6. use Cocur\Slugify\Slugify;
  7. use Doctrine\ORM\Mapping as ORM;
  8. use App\Repository\UserRepository;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Doctrine\Common\Collections\Collection;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Validator\Constraints as Assert;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  14. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  16. #[ORM\Entity(repositoryClass: UserRepository::class)]
  17. #[ORM\Table(name: '`user`')]
  18. #[ORM\HasLifecycleCallbacks]
  19. #[UniqueEntity(fields: ['email'], message: 'Il existe déjà un compte avec cette adresse e-mail')]
  20. class User implements UserInterface, PasswordAuthenticatedUserInterface
  21. {
  22.     #[ORM\Id]
  23.     #[ORM\GeneratedValue]
  24.     #[ORM\Column]
  25.     private ?int $id = null;
  28.     #[ORM\Column(type: 'string', length:255)]
  29.     #[Assert\NotBlank(message: "Veuillez renseigner ce champ")]
  30.     private $denomination;
  32.     #[ORM\Column(type: 'string', length: 255)]
  33.     private $contactEntreprise;
  35.     #[ORM\Column(type: 'string', length: 255)]
  36.     #[Assert\NotBlank(message: "Veuillez renseigner un email valide")]
  37.     private $emailEntreprise;
  39.     #[ORM\Column(type: 'string', length: 255)]
  40.     #[Assert\NotBlank(message: "Veuillez renseigner ce champ")]
  41.     private $nomPrenom;
  43.     #[ORM\Column(type: 'string', length: 255)]
  44.     private $contactInterlocuteur;
  46.     #[ORM\Column(type: 'string', length: 255)]
  47.     private $fonction;
  49.     #[ORM\Column(length: 180, unique: true)]
  50.     private ?string $email = null;
  52.     /**
  53.      * @var string The hashed password
  54.      */
  55.     #[ORM\Column]
  56.     private ?string $password = null;
  58.     #[Assert\EqualTo(propertyPath:"password", message: "Les deux mot de passes ne sont pas identiques")]
  59.     public $passwordConfirm;
  61.     #[ORM\Column(type: 'string', length: 255)]
  62.     private $slug;
  64.     #[ORM\Column]
  65.     private ?\DateTime $createdAt = null;
  67.     #[ORM\Column(type: 'string', length: 255)]
  68.     private $adresse;
  70.     #[ORM\Column]
  71.     private ?bool $active = null;
  73.     #[ORM\OneToMany(mappedBy: 'clientAssocie', targetEntity: Ce::class)]
  74.     private $userCes;
  76.     #[ORM\OneToMany(mappedBy: 'clientAssocie', targetEntity: Cv::class)]
  77.     private Collection $userCvs;
  79.     // #[ORM\OneToMany(mappedBy: 'clientAssocie', targetEntity: Cv::class)]
  80.     // private $cvs;
  82.     #[ORM\Column(type: 'json')]
  83.     private $roles = [];
  85.     #[ORM\ManyToOne(inversedBy: 'users')]
  86.     #[ORM\JoinColumn(nullable: false)]
  87.     private ?TypeUser $typesUser = null;
  89.     #[ORM\Column(type: 'boolean')]
  90.     private $isVerified = false;
  94.     // #[ORM\ManyToOne(targetEntity: TypeUser::class, inversedBy: 'users')]
  95.     // #[ORM\JoinColumn(nullable: false)]
  96.     // private $typeUser;
  99.     public function __construct()
  100.     {
  101.         $this->userCes = new ArrayCollection();
  102.         //$this->cvs = new ArrayCollection();
  103.         //$this->userRoles = ArrayCollection();
  104.         $this->userCvs = new ArrayCollection();
  105.     }
  107.     /**
  108.      * Fonction permettant d'initialiser le slug de l'utilisateur
  109.      * @return void
  110.      */
  111.     #[ORM\PrePersist]
  112.     #[ORM\PreUpdate]
  113.     public function creationSlug()
  114.     {
  115.         if (empty($this->slug)) {
  116.             $slugify = new Slugify();
  117.             $this->slug = $slugify->slugify($this->denomination);
  118.         }
  119.     }
  122.     /**
  123.      * Fonction permettant de calculer le prix en fonction de la durée du séjour et de mettre automatiquement
  124.      * à jours la date de reservation
  125.      */
  126.     #[ORM\PrePersist]
  127.     public function prePersist()
  128.     {
  129.         if (empty($this->createdAt)) {
  130.             $this->createdAt = new \DateTime();
  131.         }
  132.     }
  134.     public function getId(): ?int
  135.     {
  136.         return $this->id;
  137.     }
  139.     public function getEmail(): ?string
  140.     {
  141.         return $this->email;
  142.     }
  144.     public function setEmail(string $email): self
  145.     {
  146.         $this->email = $email;
  148.         return $this;
  149.     }
  151.     /**
  152.      * A visual identifier that represents this user.
  153.      *
  154.      * @see UserInterface
  155.      */
  156.     public function getUserIdentifier(): string
  157.     {
  158.         return (string) $this->email;
  159.     }
  161.     /**
  162.      * @see UserInterface
  163.      */
  164.     public function getRoles(): array
  165.     {
  166.         $roles = $this->roles;
  168.         // if(empty($roles)){
  169.         //     // guarantee every user at least has ROLE_USER
  170.         //     $roles[] = 'ROLE_USER';
  171.         // }
  172.         return array_unique($roles);
  173.     }
  175.     public function hasRole($roles)
  176.     {
  177.         $user_role = $this->getRoles();
  178.         if (!in_array($roles, $user_role)) {
  179.             return false;
  180.         }
  181.         return true;
  182.     }
  183.     
  185.     public function setRoles(array $roles): self
  186.     {
  187.         $this->roles = $roles;
  189.         return $this;
  190.     }
  192.     /**
  193.      * @see PasswordAuthenticatedUserInterface
  194.      */
  195.     public function getPassword(): string
  196.     {
  197.         return $this->password;
  198.     }
  200.     public function setPassword(string $password): self
  201.     {
  202.         $this->password = $password;
  204.         return $this;
  205.     }
  207.     /**
  208.      * @see UserInterface
  209.      */
  210.     public function eraseCredentials()
  211.     {
  212.         // If you store any temporary, sensitive data on the user, clear it here
  213.         // $this->plainPassword = null;
  214.     }
  216.     //Fonction permettant de retourner le nom d'utilisateur 
  217.     public function getUsername()
  218.     {
  219.         return $this->email;
  220.     }
  222.     // /**
  223.     //  * Get the value of typeUser
  224.     //  */ 
  225.     // public function getTypeUser()
  226.     // {
  227.     //     return $this->typeUser;
  228.     // }
  230.     // /**
  231.     //  * Set the value of typeUser
  232.     //  *
  233.     //  * @return  self
  234.     //  */ 
  235.     // public function setTypeUser($typeUser)
  236.     // {
  237.     //     $this->typeUser = $typeUser;
  239.     //     return $this;
  240.     // }
  242.     /**
  243.      * Get the value of adresse
  244.      */ 
  245.     public function getAdresse()
  246.     {
  247.         return $this->adresse;
  248.     }
  250.     /**
  251.      * Set the value of adresse
  252.      *
  253.      * @return  self
  254.      */ 
  255.     public function setAdresse($adresse)
  256.     {
  257.         $this->adresse = $adresse;
  259.         return $this;
  260.     }
  262.     /**
  263.      * Get the value of active
  264.      */ 
  265.     public function getActive(): ?bool
  266.     {
  267.         return $this->active;
  268.     }
  270.     /**
  271.      * Set the value of active
  272.      *
  273.      * @return  self
  274.      */ 
  275.     public function setActive(bool $active): self
  276.     {
  277.         $this->active = $active;
  279.         return $this;
  280.     }
  282.     /**
  283.      * Get the value of userCes
  284.      * @return Collection|Ce[]
  285.      */ 
  286.     public function getUserCes(): Collection
  287.     {
  288.         return $this->userCes;
  289.     }
  291.     /**
  292.      * Set the value of userCes
  293.      *
  294.      * @return  self
  295.      */
  296.     public function addUserCe(Ce $userCe): self
  297.     {
  298.         if (!$this->userCes->contains($userCe)) {
  299.             $this->userCes[] = $userCe;
  300.             $userCe->setClientAssocie($this);
  301.         }
  303.         return $this;
  304.     }
  307.     public function removeUserCe(Ce $userCe): self
  308.     {
  309.         if ($this->userCes->contains($userCe)) {
  310.             $this->userCes->removeElement($userCe);
  311.             // set the owning side to null (unless already changed)
  312.             if ($userCe->getClientAssocie() === $this) {
  313.                 $userCe->setClientAssocie(null);
  314.             }
  315.         }
  317.         return $this;
  318.     }
  320.     // /**
  321.     //  * @return Collection|Cv[]
  322.     //  */
  323.     // public function getCvs(): Collection
  324.     // {
  325.     //     return $this->cvs;
  326.     // }
  328.     // public function addCv(Cv $cv): self
  329.     // {
  330.     //     if (!$this->cvs->contains($cv)) {
  331.     //         $this->cvs[] = $cv;
  332.     //         $cv->setClientAssocie($this);
  333.     //     }
  335.     //     return $this;
  336.     // }
  339.     // public function removeCv(Cv $cv): self
  340.     // {
  341.     //     if ($this->cvs->contains($cv)) {
  342.     //         $this->cvs->removeElement($cv);
  343.     //         // set the owning side to null (unless already changed)
  344.     //         if ($cv->getClientAssocie() === $this) {
  345.     //             $cv->setClientAssocie(null);
  346.     //         }
  347.     //     }
  349.     //     return $this;
  350.     // }
  353.     /**
  354.      * Get the value of contactEntreprise
  355.      */ 
  356.     public function getContactEntreprise(): ?string
  357.     {
  358.         return $this->contactEntreprise;
  359.     }
  361.     /**
  362.      * Set the value of contactEntreprise
  363.      *
  364.      * @return  self
  365.      */ 
  366.     public function setContactEntreprise(string $contactEntreprise): self
  367.     {
  368.         $this->contactEntreprise = $contactEntreprise;
  370.         return $this;
  371.     }
  373.     /**
  374.      * Get the value of emailEntreprise
  375.      */ 
  376.     public function getEmailEntreprise(): ?string
  377.     {
  378.         return $this->emailEntreprise;
  379.     }
  381.     /**
  382.      * Set the value of emailEntreprise
  383.      *
  384.      * @return  self
  385.      */ 
  386.     public function setEmailEntreprise(string $emailEntreprise): self
  387.     {
  388.         $this->emailEntreprise = $emailEntreprise;
  390.         return $this;
  391.     }
  393.     /**
  394.      * Get the value of nomPrenom
  395.      */ 
  396.     public function getNomPrenom(): ?string
  397.     {
  398.         return $this->nomPrenom;
  399.     }
  401.     /**
  402.      * Set the value of nomPrenom
  403.      *
  404.      * @return  self
  405.      */ 
  406.     public function setNomPrenom(string $nomPrenom): self
  407.     {
  408.         $this->nomPrenom = $nomPrenom;
  410.         return $this;
  411.     }
  413.     /**
  414.      * Get the value of contactInterlocuteur
  415.      */ 
  416.     public function getContactInterlocuteur(): ?string
  417.     {
  418.         return $this->contactInterlocuteur;
  419.     }
  421.     /**
  422.      * Set the value of contactInterlocuteur
  423.      *
  424.      * @return  self
  425.      */ 
  426.     public function setContactInterlocuteur(string $contactInterlocuteur): self
  427.     {
  428.         $this->contactInterlocuteur = $contactInterlocuteur;
  430.         return $this;
  431.     }
  433.     /**
  434.      * Get the value of fonction
  435.      */ 
  436.     public function getFonction(): ?string
  437.     {
  438.         return $this->fonction;
  439.     }
  441.     /**
  442.      * Set the value of fonction
  443.      *
  444.      * @return  self
  445.      */ 
  446.     public function setFonction(string $fonction)
  447.     {
  448.         $this->fonction = $fonction;
  450.         return $this;
  451.     }
  453.     /**
  454.      * Get the value of denomination
  455.      */ 
  456.     public function getDenomination()
  457.     {
  458.         return $this->denomination;
  459.     }
  461.     /**
  462.      * Set the value of denomination
  463.      *
  464.      * @return  self
  465.      */ 
  466.     public function setDenomination(string $denomination): self
  467.     {
  468.         $this->denomination = $denomination;
  470.         return $this;
  471.     }
  473.     public function getSalt(): ?string
  474.     {
  475.         return null;
  476.     }
  478.     public function getCreatedAt(): ?\DateTimeInterface
  479.     {
  480.         return $this->createdAt;
  481.     }
  483.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  484.     {
  485.         $this->createdAt = $createdAt;
  487.         return $this;
  488.     }
  490.     /**
  491.      * @return Collection<int, Cv>
  492.      */
  493.     public function getUserCvs(): Collection
  494.     {
  495.         return $this->userCvs;
  496.     }
  498.     public function addUserCv(Cv $userCv): self
  499.     {
  500.         if (!$this->userCvs->contains($userCv)) {
  501.             $this->userCvs->add($userCv);
  502.             $userCv->setClientAssocie($this);
  503.         }
  505.         return $this;
  506.     }
  508.     public function removeUserCv(Cv $userCv): self
  509.     {
  510.         if ($this->userCvs->removeElement($userCv)) {
  511.             // set the owning side to null (unless already changed)
  512.             if ($userCv->getClientAssocie() === $this) {
  513.                 $userCv->setClientAssocie(null);
  514.             }
  515.         }
  517.         return $this;
  518.     }
  520.     public function getTypesUser(): ?TypeUser
  521.     {
  522.         return $this->typesUser;
  523.     }
  525.     public function setTypesUser(?TypeUser $typesUser): self
  526.     {
  527.         $this->typesUser = $typesUser;
  529.         return $this;
  530.     }
  533.     /**
  534.      * Get the value of slug
  535.      */ 
  536.     public function getSlug()
  537.     {
  538.         return $this->slug;
  539.     }
  541.     /**
  542.      * Set the value of slug
  543.      *
  544.      * @return  self
  545.      */ 
  546.     public function setSlug($slug)
  547.     {
  548.         $this->slug = $slug;
  550.         return $this;
  551.     }
  553.     public function isVerified(): bool
  554.     {
  555.         return $this->isVerified;
  556.     }
  558.     public function setIsVerified(bool $isVerified): self
  559.     {
  560.         $this->isVerified = $isVerified;
  562.         return $this;
  563.     }
  565. }