src/Entity/User.php line 24

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  6. use App\Enum\Ville;
  7. use DateTime;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use App\Repository\UserRepository;
  10. use Doctrine\Common\Collections\Collection;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use PhpParser\Node\Expr\BinaryOp\BooleanOr;
  13. use Symfony\Component\Validator\Constraints as Assert;
  14. use Vich\UploaderBundle\Mapping\Annotation\Uploadable;
  15. use Symfony\Component\Security\Core\User\UserInterface;
  16. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  17. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  19. /**
  20.  * @ORM\Entity(repositoryClass=UserRepository::class)
  21.  * @UniqueEntity("email" , message="Cette adresse est déja utiliseé")
  22.  * @Vich\Uploadable
  23.  */
  24. class User implements UserInterface
  25. {
  26.     /**
  27.      * @ORM\Id
  28.      * @ORM\GeneratedValue
  29.      * @ORM\Column(type="integer")
  30.      */
  31.     private $id;
  33.     /**
  34.      * @ORM\Column(type="string", length=180, unique=true)
  35.      * @Assert\Email(
  36.      *     message = "The email '{{ value }}' is not a valid email."
  37.      * )
  38.      * @Assert\NotBlank(
  39.      *  message= "champs email est obligatiore."
  40.      * ) 
  41.      */
  42.     private $email;
  44.     /**
  45.      * @ORM\Column(type="json")
  46.      */
  47.     private $roles = [];
  49.   
  50.     /**
  51.      * @var string The hashed password
  52.      * @ORM\Column(type="string",nullable=true)
  53.      * @Assert\NotBlank(
  54.      *  message= "champs password est obligatiore."
  55.      * )
  56.      * @Assert\Length(min="8", minMessage="Votre mot de passe doit faire minimum 8 caractéres")
  57.      * @Assert\EqualTo(propertyPath="confirm_password", message="Le mot de passe et sa confirmation ne coïncident pas. ")
  58.      */
  59.     private $password;
  61.     /**
  62.      * @Assert\NotBlank(
  63.      *  message= "champs confirm password est obligatiore."
  64.      * ) 
  65.      * @Assert\EqualTo(propertyPath="password")
  66.      */
  67.     public $confirm_password;
  69.     /**
  70.      * @ORM\Column(type="datetime")
  71.      */
  72.     private $createdAt;
  74.     /**
  75.      * @ORM\Column(type="string", length=255)
  76.      * @Assert\NotBlank(
  77.      *  message= "champs username est obligatiore."
  78.      * ) 
  79.      */
  80.     private $username;
  82.     /**
  83.      * @ORM\Column(type="string", length=255, nullable=true)
  84.      */
  85.     private $token;
  87.     /**
  88.      * @ORM\Column(type="string", length=255)
  89.      * @Assert\NotBlank(
  90.      *  message= "champs lastname est obligatiore."
  91.      * ) 
  92.      */
  93.     private $lastname;
  95.     /**
  96.      * @ORM\Column(type="string", length=255)
  97.      * @Assert\NotBlank(
  98.      *  message= "champs phone est obligatiore."
  99.      * ) 
  100.      * @Assert\Length(min="8", minMessage="Votre numreo de Télèphone doit contenir 8 chiffres")
  101.      */
  102.     private $phone;
  104.     /**
  105.      * @ORM\Column(type="string", length=255,nullable=true)
  106.      * @Assert\NotBlank(
  107.      *  message= "champs address est obligatiore."
  108.      * ) 
  110.      */
  111.     private $address;
  113.     /**
  114.      * @ORM\Column(type="string", length=255)
  115.      * @Assert\NotBlank(
  116.      *  message= "champs ville est obligatiore."
  117.      * ) 
  119.      */
  120.     private $ville;
  122.     /**
  123.      * @ORM\OneToMany(targetEntity=Demande::class, mappedBy="user")
  124.      */
  125.     private $demandes;
  128.     /**
  129.      * @ORM\OneToMany(targetEntity=Comments::class, mappedBy="user")
  130.      */
  131.     private $comments;
  133.     /**
  134.      * @ORM\OneToMany(targetEntity=Offre::class, mappedBy="user")
  135.      */
  136.     private $offres;
  138.     /**
  139.      * @ORM\OneToMany(targetEntity=CommentOffre::class, mappedBy="user")
  140.      */
  141.     private $commentOffres;
  143.     /**
  144.      * @ORM\OneToOne(targetEntity=UserImage::class, mappedBy="userImages", cascade={"persist", "remove"})
  145.      */
  146.     private $userImage;
  148.     /**
  149.      * @ORM\Column(type="string", length=255, nullable=true)
  150.      */
  151.     private $reset_token;
  153.     /**
  154.      * @ORM\Column(type="datetime", nullable=true)
  155.      * @Assert\NotBlank(
  156.      *  message= "champs date naissance est obligatiore."
  157.      * ) 
  159.      */
  160.     private $naissance;
  162.     /**
  163.      * @ORM\Column(type="string", nullable=true)
  164.      */
  165.     private $experience;
  167.     /**
  168.      * @ORM\Column(type="string", nullable=true)
  169.      * @Assert\Length(
  170.      *      min = 10,
  171.      *      max = 12,
  172.      *      minMessage = "numéro social doit avoir  {{ limit }} chiffres minimum",
  173.      *      maxMessage = "Numéro social doit avoir {{ limit }} chiffres maximum"
  174.      * )
  175.      */
  176.     private $sociale;
  178.     /**
  179.      * @ORM\Column(type="string", nullable=true) 
  180.      * @Assert\Length(
  181.      *      min = 20,
  182.      *      max = 20,
  183.      *      minMessage = "numéro bancaire doit avoir  {{ limit }} chiffres minimum",
  184.      *      maxMessage = "Numéro bancaire doit avoir {{ limit }} chiffres maximum"
  185.      * )
  186.      */
  187.     private $bancaire;
  189.     /**
  190.      * @ORM\Column(type="string", nullable=true)
  191.      */
  192.     private $cv;
  194.     /**
  195.      * @ORM\Column(type="string", nullable=true)
  196.      */
  197.     private $identite;
  199.     /**
  200.      * @ORM\Column(type="string", nullable=true)
  201.      */
  202.     private $logo;
  204.     /**
  205.      * @ORM\Column(type="string", length=255, nullable=true)
  206.      */
  207.     private $etablissement;
  209.     /**
  210.      * @ORM\Column(type="string", length=255, nullable=true)
  211.      */
  212.     private $a_propos;
  214.     /**
  215.      * @ORM\Column(type="string", length=255, nullable=true)
  216.      * @Assert\Length(
  217.      *      min = 8,
  218.      *      max = 12,
  219.      *      minMessage = "numéro matricule doit avoir  {{ limit }} chiffres minimum",
  220.      *      maxMessage = "Numéro matricule doit avoir {{ limit }} chiffres maximum"
  221.      * )
  222.      */
  223.     private $matricule;
  225.     /**
  226.      * @ORM\Column(type="boolean", nullable=true)
  227.      */
  228.     private $isBlocked;
  230.     /**
  231.      * @ORM\Column(type="boolean", nullable=true)
  232.      */
  233.     private $enabled;
  235.     /**
  236.      * @ORM\OneToMany(targetEntity=Candidature::class, mappedBy="user")
  237.      */
  238.     private $candidatures;
  242.     public function __construct()
  243.     {
  244.         $this->roles = ['ROLE_USER'];
  245.         $this->createdAt = new \DateTime();
  246.         $this->enabled = false;
  247.         $this->isBlocked = false;
  248.         $this->demandes = new ArrayCollection();
  249.         $this->comments = new ArrayCollection();
  250.         $this->offres = new ArrayCollection();
  251.         $this->commentOffres = new ArrayCollection();
  252.         $this->candidatures = new ArrayCollection();
  253.     }
  256.     public function getId(): ?int
  257.     {
  258.         return $this->id;
  259.     }
  261.     public function getEmail(): ?string
  262.     {
  263.         return $this->email;
  264.     }
  266.     public function setEmail(string $email): self
  267.     {
  268.         $this->email = $email;
  270.         return $this;
  271.     }
  273.     /**
  274.      * A visual identifier that represents this user.
  275.      *
  276.      * @see UserInterface
  277.      */
  278.     public function getUsername(): string
  279.     {
  280.         //return (string) $this->email;
  281.         return $this->username;
  282.     }
  284.     public function getEtablissement(): ?string
  285.     {
  286.         return $this->etablissement;
  287.     }
  289.     public function setEtablissement(?string $etablissement): self
  290.     {
  291.         $this->etablissement = $etablissement;
  293.         return $this;
  294.     }
  296.     public function getAPropos(): ?string
  297.     {
  298.         return $this->a_propos;
  299.     }
  301.     public function setAPropos(?string $a_propos): self
  302.     {
  303.         $this->a_propos = $a_propos;
  305.         return $this;
  306.     }
  308.     public function getMatricule(): ?string
  309.     {
  310.         return $this->matricule;
  311.     }
  313.     public function setMatricule(?string $matricule): self
  314.     {
  315.         $this->matricule = $matricule;
  317.         return $this;
  318.     }
  320.     /**
  321.      * @see UserInterface
  322.      */
  323.     public function getRoles(): array
  324.     {
  325.         $roles = $this->roles;
  326.         // guarantee every user at least has ROLE_USER
  327.         $roles[] = 'ROLE_USER';
  329.         return array_unique($roles);
  330.     }
  332.     public function setRoles(array $roles): self
  333.     {
  334.         $this->roles = $roles;
  336.         return $this;
  337.     }
  340.     /**
  341.      * @see UserInterface
  342.      */
  343.     public function getPassword(): string
  344.     {
  345.         return (string) $this->password;
  346.     }
  348.     public function setPassword(string $password): self
  349.     {
  350.         $this->password = $password;
  352.         return $this;
  353.     }
  355.     /**
  356.      * Returning a salt is only needed, if you are not using a modern
  357.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  358.      *
  359.      * @see UserInterface
  360.      */
  361.     public function getSalt(): ?string
  362.     {
  363.         return null;
  364.     }
  366.     /**
  367.      * @see UserInterface
  368.      */
  369.     public function eraseCredentials()
  370.     {
  371.         // If you store any temporary, sensitive data on the user, clear it here
  372.         // $this->plainPassword = null;
  373.     }
  375.     public function getCreatedAt(): ?\DateTimeInterface
  376.     {
  377.         return $this->createdAt;
  378.     }
  380.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  381.     {
  382.         $this->createdAt = $createdAt;
  384.         return $this;
  385.     }
  387.     public function getEnabled(): ?bool
  388.     {
  389.         return $this->enabled;
  390.     }
  392.     public function setEnabled(bool $enabled): self
  393.     {
  394.         $this->enabled = $enabled;
  396.         return $this;
  397.     }
  399.     public function setUsername(string $username): self
  400.     {
  401.         $this->username = $username;
  403.         return $this;
  404.     }
  406.     public function getToken(): ?string
  407.     {
  408.         return $this->token;
  409.     }
  411.     public function setToken(?string $token): self
  412.     {
  413.         $this->token = $token;
  415.         return $this;
  416.     }
  418.     public function getLastname(): ?string
  419.     {
  420.         return $this->lastname;
  421.     }
  423.     public function setLastname(string $lastname): self
  424.     {
  425.         $this->lastname = $lastname;
  427.         return $this;
  428.     }
  429.     public function getPhone(): ?string
  430.     {
  431.         return $this->phone;
  432.     }
  434.     public function setPhone(string $phone): self
  435.     {
  436.         $this->phone = $phone;
  438.         return $this;
  439.     }
  441.     public function getAddress(): ?string
  442.     {
  443.         return $this->address;
  444.     }
  446.     public function setAddress(string $address): self
  447.     {
  448.         $this->address = $address;
  450.         return $this;
  451.     }
  453.     public function getVille(): ?string
  454.     {
  455.         return $this->ville;
  456.     }
  458.     public function setVille(string $ville): self
  459.     {
  460.         $this->ville = $ville;
  462.         return $this;
  463.     }
  465.     /**
  466.      * @return Collection|Demande[]
  467.      */
  468.     public function getDemandes(): Collection
  469.     {
  470.         return $this->demandes;
  471.     }
  473.     public function addDemande(Demande $demande): self
  474.     {
  475.         if (!$this->demandes->contains($demande)) {
  476.             $this->demandes[] = $demande;
  477.             $demande->setUser($this);
  478.         }
  480.         return $this;
  481.     }
  483.     public function removeDemande(Demande $demande): self
  484.     {
  485.         if ($this->demandes->removeElement($demande)) {
  486.             // set the owning side to null (unless already changed)
  487.             if ($demande->getUser() === $this) {
  488.                 $demande->setUser(null);
  489.             }
  490.         }
  492.         return $this;
  493.     }
  495.     public function __toString()
  496.     {
  497.         return $this->username;
  498.     }
  500.     /**
  501.      * @return Collection|Comments[]
  502.      */
  503.     public function getComments(): Collection
  504.     {
  505.         return $this->comments;
  506.     }
  508.     public function addComment(Comments $comment): self
  509.     {
  510.         if (!$this->comments->contains($comment)) {
  511.             $this->comments[] = $comment;
  512.             $comment->setUser($this);
  513.         }
  515.         return $this;
  516.     }
  518.     public function removeComment(Comments $comment): self
  519.     {
  520.         if ($this->comments->removeElement($comment)) {
  521.             // set the owning side to null (unless already changed)
  522.             if ($comment->getUser() === $this) {
  523.                 $comment->setUser(null);
  524.             }
  525.         }
  527.         return $this;
  528.     }
  530.     /**
  531.      * @return Collection|Offre[]
  532.      */
  533.     public function getOffres(): Collection
  534.     {
  535.         return $this->offres;
  536.     }
  538.     public function addOffre(Offre $offre): self
  539.     {
  540.         if (!$this->offres->contains($offre)) {
  541.             $this->offres[] = $offre;
  542.             $offre->setUser($this);
  543.         }
  545.         return $this;
  546.     }
  548.     public function removeOffre(Offre $offre): self
  549.     {
  550.         if ($this->offres->removeElement($offre)) {
  551.             // set the owning side to null (unless already changed)
  552.             if ($offre->getUser() === $this) {
  553.                 $offre->setUser(null);
  554.             }
  555.         }
  557.         return $this;
  558.     }
  560.     /**
  561.      * @return Collection|CommentOffre[]
  562.      */
  563.     public function getCommentOffres(): Collection
  564.     {
  565.         return $this->commentOffres;
  566.     }
  568.     public function addCommentOffre(CommentOffre $commentOffre): self
  569.     {
  570.         if (!$this->commentOffres->contains($commentOffre)) {
  571.             $this->commentOffres[] = $commentOffre;
  572.             $commentOffre->setUser($this);
  573.         }
  575.         return $this;
  576.     }
  578.     public function removeCommentOffre(CommentOffre $commentOffre): self
  579.     {
  580.         if ($this->commentOffres->removeElement($commentOffre)) {
  581.             // set the owning side to null (unless already changed)
  582.             if ($commentOffre->getUser() === $this) {
  583.                 $commentOffre->setUser(null);
  584.             }
  585.         }
  587.         return $this;
  588.     }
  590.     public function getUserImage(): ?UserImage
  591.     {
  592.         return $this->userImage;
  593.     }
  595.     public function setUserImage(?UserImage $userImage): self
  596.     {
  597.         // unset the owning side of the relation if necessary
  598.         if ($userImage === null && $this->userImage !== null) {
  599.             $this->userImage->setUserImages(null);
  600.         }
  602.         // set the owning side of the relation if necessary
  603.         if ($userImage !== null && $userImage->getUserImages() !== $this) {
  604.             $userImage->setUserImages($this);
  605.         }
  607.         $this->userImage = $userImage;
  609.         return $this;
  610.     }
  612.     public function getResetToken(): ?string
  613.     {
  614.         return $this->reset_token;
  615.     }
  617.     public function setResetToken(?string $reset_token): self
  618.     {
  619.         $this->reset_token = $reset_token;
  621.         return $this;
  622.     }
  624.     public function getNaissance(): ?Datetime
  625.     {
  626.         return $this->naissance;
  627.     }
  629.     public function setNaissance(DateTime $naissance): self
  630.     {
  631.         $this->naissance = $naissance;
  633.         return $this;
  634.     }
  636.     public function getExperience(): ?string
  637.     {
  638.         return $this->experience;
  639.     }
  641.     public function setExperience(string $experience): self
  642.     {
  643.         $this->experience = $experience;
  645.         return $this;
  646.     }
  648.     public function getSociale(): ?string
  649.     {
  650.         return $this->sociale;
  651.     }
  653.     public function setSociale(string $sociale): self
  654.     {
  655.         $this->sociale = $sociale;
  657.         return $this;
  658.     }
  660.     public function getBancaire(): ?string
  661.     {
  662.         return $this->bancaire;
  663.     }
  665.     public function setBancaire(string $bancaire): self
  666.     {
  667.         $this->bancaire = $bancaire;
  669.         return $this;
  670.     }
  672.     public function getCv(): ?string
  673.     {
  674.         return $this->cv;
  675.     }
  677.     public function setLogo(string $logo): self
  678.     {
  679.         $this->logo = $logo;
  681.         return $this;
  682.     }
  684.     public function getLogo(): ?string
  685.     {
  686.         return $this->logo;
  687.     }
  689.     public function setCv(string $cv): self
  690.     {
  691.         $this->cv = $cv;
  693.         return $this;
  694.     }
  696.     public function getIdentite(): ?string
  697.     {
  698.         return $this->identite;
  699.     }
  701.     public function setIdentite(string $identite): self
  702.     {
  703.         $this->identite = $identite;
  705.         return $this;
  706.     }
  708.     public function getIsBlocked(): ?bool
  709.     {
  710.         return $this->isBlocked;
  711.     }
  713.     public function setIsBlocked(bool $isBlocked): self
  714.     {
  715.         $this->isBlocked = $isBlocked;
  717.         return $this;
  718.     }
  720.     /**
  721.      * @return Collection|Candidature[]
  722.      */
  723.     public function getCandidatures(): Collection
  724.     {
  725.         return $this->candidatures;
  726.     }
  728.     public function addCandidature(Candidature $candidature): self
  729.     {
  730.         if (!$this->candidatures->contains($candidature)) {
  731.             $this->candidatures[] = $candidature;
  732.             $candidature->setUser($this);
  733.         }
  735.         return $this;
  736.     }
  738.     public function removeCandidature(Candidature $candidature): self
  739.     {
  740.         if ($this->candidatures->removeElement($candidature)) {
  741.             // set the owning side to null (unless already changed)
  742.             if ($candidature->getUser() === $this) {
  743.                 $candidature->setUser(null);
  744.             }
  745.         }
  747.         return $this;
  748.     }
  749. }