src/Entity/User.php line 15

Open in your IDE?
  1. <?php
  2. namespace App\Entity;
  3. use App\Repository\UserRepository;
  4. use Doctrine\Common\Collections\ArrayCollection;
  5. use Doctrine\Common\Collections\Collection;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  8. use Symfony\Component\Security\Core\User\UserInterface;
  9. /**
  10.  * @ORM\Entity(repositoryClass=UserRepository::class)
  11.  */
  12. class User implements UserInterfacePasswordAuthenticatedUserInterface
  13. {
  14.     const AGE_25 '< 25';
  15.     const AGE_25_35 '25-35';
  16.     const AGE_35_45 '35-45';
  17.     const AGE_45_55 '45-55';
  18.     const AGE_55 '> 55';
  19.     const LEVEL_BAC 'BAC';
  20.     const LEVEL_BAC2 'BAC+2';
  21.     const LEVEL_BAC3 'BAC+3';
  22.     const LEVEL_BAC4 'BAC+4';
  23.     const LEVEL_BAC5 'BAC+5';
  24.     const NB_MANAGED_10 '< 10';
  25.     const NB_MANAGED_10_20 '10-20';
  26.     const NB_MANAGED_20_30 '20-30';
  27.     const NB_MANAGED_30 '> 30';
  28.     /**
  29.      * @ORM\Id
  30.      * @ORM\GeneratedValue
  31.      * @ORM\Column(type="integer")
  32.      */
  33.     private $id;
  34.     /**
  35.      * @ORM\Column(type="string", length=180, unique=true)
  36.      */
  37.     private $email;
  38.     /**
  39.      * @ORM\Column(type="json")
  40.      */
  41.     private $roles = [];
  42.     /**
  43.      * @var string The hashed password
  44.      * @ORM\Column(type="string")
  45.      */
  46.     private $password;
  47.     /**
  48.      * @ORM\Column(type="string", length=255)
  49.      */
  50.     private $firstName;
  51.     /**
  52.      * @ORM\Column(type="string", length=255)
  53.      */
  54.     private $lastName;
  55.     /**
  56.      * @ORM\Column(type="string", length=255)
  57.      */
  58.     private $poste;
  59.     /**
  60.      * @ORM\Column(type="string", length=255, nullable=true)
  61.      */
  62.     private $age;
  63.     /**
  64.      * @ORM\Column(type="string", length=255, nullable=true)
  65.      */
  66.     private $level;
  67.     /**
  68.      * @ORM\Column(type="string", length=255, nullable=true)
  69.      */
  70.     private $diplome;
  71.     /**
  72.      * @ORM\Column(type="boolean", nullable=true)
  73.      */
  74.     private $initialTrained;
  75.     /**
  76.      * @ORM\Column(type="boolean", nullable=true)
  77.      */
  78.     private $alreadyTrained;
  79.     /**
  80.      * @ORM\Column(type="integer", nullable=true)
  81.      */
  82.     private $experience;
  83.     /**
  84.      * @ORM\OneToMany(targetEntity=Respondent::class, mappedBy="user")
  85.      */
  86.     private $respondents;
  87.     /**
  88.      * @ORM\Column(type="string", length=255, nullable=true)
  89.      */
  90.     private $nbManaged;
  91.     public function __construct()
  92.     {
  93.         $this->respondents = new ArrayCollection();
  94.     }
  95.     public function getId(): ?int
  96.     {
  97.         return $this->id;
  98.     }
  99.     public function getEmail(): ?string
  100.     {
  101.         return $this->email;
  102.     }
  103.     public function setEmail(string $email): self
  104.     {
  105.         $this->email $email;
  106.         return $this;
  107.     }
  108.     /**
  109.      * A visual identifier that represents this user.
  110.      *
  111.      * @see UserInterface
  112.      */
  113.     public function getUserIdentifier(): string
  114.     {
  115.         return (string) $this->email;
  116.     }
  117.     /**
  118.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  119.      */
  120.     public function getUsername(): string
  121.     {
  122.         return (string) $this->email;
  123.     }
  124.     /**
  125.      * @see UserInterface
  126.      */
  127.     public function getRoles(): array
  128.     {
  129.         $roles $this->roles;
  130.         // guarantee every user at least has ROLE_USER
  131.         $roles[] = 'ROLE_USER';
  132.         return array_unique($roles);
  133.     }
  134.     public function setRoles(array $roles): self
  135.     {
  136.         $this->roles $roles;
  137.         return $this;
  138.     }
  139.     /**
  140.      * @see PasswordAuthenticatedUserInterface
  141.      */
  142.     public function getPassword(): string
  143.     {
  144.         return $this->password;
  145.     }
  146.     public function setPassword(string $password): self
  147.     {
  148.         $this->password $password;
  149.         return $this;
  150.     }
  151.     /**
  152.      * Returning a salt is only needed, if you are not using a modern
  153.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  154.      *
  155.      * @see UserInterface
  156.      */
  157.     public function getSalt(): ?string
  158.     {
  159.         return null;
  160.     }
  161.     /**
  162.      * @see UserInterface
  163.      */
  164.     public function eraseCredentials()
  165.     {
  166.         // If you store any temporary, sensitive data on the user, clear it here
  167.         // $this->plainPassword = null;
  168.     }
  169.     public function getFirstName(): ?string
  170.     {
  171.         return $this->firstName;
  172.     }
  173.     public function setFirstName(string $firstName): self
  174.     {
  175.         $this->firstName $firstName;
  176.         return $this;
  177.     }
  178.     public function getLastName(): ?string
  179.     {
  180.         return $this->lastName;
  181.     }
  182.     public function setLastName(string $lastName): self
  183.     {
  184.         $this->lastName $lastName;
  185.         return $this;
  186.     }
  187.     public function getPoste(): ?string
  188.     {
  189.         return $this->poste;
  190.     }
  191.     public function setPoste(string $poste): self
  192.     {
  193.         $this->poste $poste;
  194.         return $this;
  195.     }
  196.     public function getAge(): ?string
  197.     {
  198.         return $this->age;
  199.     }
  200.     public function getAgeAsString()
  201.     {
  202.         $age ='';
  203.         switch ($this->age) {
  204.             case User::AGE_25:
  205.                 $age 'Moins de 25 ans';
  206.                 break;
  207.             case User::AGE_25_35:
  208.                 $age 'Entre 25 et 35 ans';
  209.                 break;
  210.             case User::AGE_35_45:
  211.                 $age 'Entre 35 et 45 ans';
  212.                 break;
  213.             case User::AGE_45_55:
  214.                 $age 'Entre 45 et 55 ans';
  215.                 break;
  216.             case User::AGE_55:
  217.                 $age 'Plus de 55 ans';
  218.                 break;
  219.             default:
  220.                 break;
  221.         }
  222.         return $age;
  223.     }
  224.     public function setAge(?string $age): self
  225.     {
  226.         $this->age $age;
  227.         return $this;
  228.     }
  229.     public function getLevel(): ?string
  230.     {
  231.         return $this->level;
  232.     }
  233.     public function getLevelAsString()
  234.     {
  235.         $level ='';
  236.         switch ($this->level) {
  237.             case User::LEVEL_BAC:
  238.                 $level 'BAC (ou infĂ©rieur)';
  239.                 break;
  240.             case User::LEVEL_BAC2:
  241.                 $level 'BAC+2';
  242.                 break;
  243.             case User::LEVEL_BAC3:
  244.                 $level 'BAC+3';
  245.                 break;
  246.             case User::LEVEL_BAC4:
  247.                 $level 'BAC+4';
  248.                 break;
  249.             case User::LEVEL_BAC5:
  250.                 $level 'BAC+5 (ou supĂ©rieur)';
  251.                 break;
  252.             default:
  253.                 break;
  254.         }
  255.         return $level;
  256.     }
  257.     public function setLevel(?string $level): self
  258.     {
  259.         $this->level $level;
  260.         return $this;
  261.     }
  262.     public function getDiplome(): ?string
  263.     {
  264.         return $this->diplome;
  265.     }
  266.     public function setDiplome(?string $diplome): self
  267.     {
  268.         $this->diplome $diplome;
  269.         return $this;
  270.     }
  271.     public function isInitialTrained(): ?bool
  272.     {
  273.         return $this->initialTrained;
  274.     }
  275.     public function setInitialTrained(?bool $initialTrained): self
  276.     {
  277.         $this->initialTrained $initialTrained;
  278.         return $this;
  279.     }
  280.     public function isAlreadyTrained(): ?bool
  281.     {
  282.         return $this->alreadyTrained;
  283.     }
  284.     public function setAlreadyTrained(?bool $alreadyTrained): self
  285.     {
  286.         $this->alreadyTrained $alreadyTrained;
  287.         return $this;
  288.     }
  289.     public function getExperience(): ?int
  290.     {
  291.         return $this->experience;
  292.     }
  293.     public function setExperience(?int $experience): self
  294.     {
  295.         $this->experience $experience;
  296.         return $this;
  297.     }
  298.     /**
  299.      * @return Collection<int, Respondent>
  300.      */
  301.     public function getRespondents(): Collection
  302.     {
  303.         return $this->respondents;
  304.     }
  305.     public function addRespondent(Respondent $respondent): self
  306.     {
  307.         if (!$this->respondents->contains($respondent)) {
  308.             $this->respondents[] = $respondent;
  309.             $respondent->setUser($this);
  310.         }
  311.         return $this;
  312.     }
  313.     public function removeRespondent(Respondent $respondent): self
  314.     {
  315.         if ($this->respondents->removeElement($respondent)) {
  316.             // set the owning side to null (unless already changed)
  317.             if ($respondent->getUser() === $this) {
  318.                 $respondent->setUser(null);
  319.             }
  320.         }
  321.         return $this;
  322.     }
  323.     public function getNbManaged(): ?string
  324.     {
  325.         return $this->nbManaged;
  326.     }
  327.     public function getNbManagedAsString()
  328.     {
  329.         $nbManaged ='';
  330.         switch ($this->nbManaged) {
  331.             case User::NB_MANAGED_10:
  332.                 $nbManaged 'Moins de 10 personnes';
  333.                 break;
  334.             case User::NB_MANAGED_10_20:
  335.                 $nbManaged 'Entre 10 et 20 personnes';
  336.                 break;
  337.             case User::NB_MANAGED_20_30:
  338.                 $nbManaged 'Entre 20 et 30 personnes';
  339.                 break;
  340.             case User::NB_MANAGED_30:
  341.                 $nbManaged 'Plus de 30 personnes';
  342.                 break;
  343.         }
  344.         return $nbManaged;
  345.     }
  346.     public function setNbManaged(?string $nbManaged): self
  347.     {
  348.         $this->nbManaged $nbManaged;
  349.         return $this;
  350.     }
  351. }