src/Entity/User.php line 15

Open in your IDE?
  1. <?php 
  2. // src/AppBundle/Entity/User.php
  3. namespace App\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Symfony\Component\Security\Core\User\UserInterface;
  8. use JMS\Serializer\Annotation as Serializer;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Doctrine\ORM\Event\PostFlushEventArgs;
  11. /**
  12.  * @ORM\Table(name="ba_user")
  13.  * @ORM\Entity(repositoryClass="App\Repository\UserRepository")
  14.  */
  15. class User implements UserInterface
  16. {
  17.     use \App\Traits\Timestampable;
  18.     // use \App\Traits\Blameable;
  20.     /**
  21.      * @ORM\Column(name="id", type="integer", nullable=false)
  22.      * @ORM\Id
  23.      * @ORM\GeneratedValue(strategy="IDENTITY")
  24.      */
  25.     private $id;
  27.     /**
  28.      * @ORM\Column(type="string", length=25, unique=true)
  29.      */
  30.     private $username;
  32.     /**
  33.      * @ORM\Column(type="string", length=64)
  34.      */
  35.     private $password;
  37.     /**
  38.      * @ORM\Column(type="string", length=100)
  39.      */
  40.     private $email;
  42.     /**
  43.      * @ORM\Column(name="is_active", type="boolean")
  44.      */
  45.     private $isActive;
  46.     /**
  47.      * @ORM\ManyToOne(targetEntity="App\Entity\Role")
  48.      */
  49.     private $role;
  51.     /**
  52.      * @ORM\Column(type="string", length=255)
  53.      */
  54.     private $firstname;
  56.     /**
  57.      * @ORM\Column(type="string", length=255)
  58.      */
  59.     private $lastname;
  61.     /**
  62.      * @ORM\OneToMany(targetEntity="App\Entity\Log", mappedBy="user_crea")
  63.      */
  64.     private $logs;
  66.     /**
  67.      * @ORM\Column(type="string", length=100, nullable=true)
  68.      */
  69.     private $phone;
  71.     /**
  72.      * @ORM\Column(type="string", length=100, nullable=true)
  73.      */
  74.     private $cellphone;
  76.     /**
  77.      * @ORM\Column(type="text", nullable=true)
  78.      */
  79.     private $address;
  81.     /**
  82.      * @ORM\Column(type="string", length=100, nullable=true)
  83.      */
  84.     private $city;
  86.     /**
  87.      * @ORM\Column(type="string", length=10, nullable=true)
  88.      */
  89.     private $zipcode;
  91.     /**
  92.      * @ORM\Column(type="string", length=255, nullable=true)
  93.      */
  94.     private $avatar;
  96.     /**
  97.      * @ORM\OneToMany(targetEntity="App\Entity\HistoriquePage", mappedBy="user")
  98.      */
  99.     private $historiquePages;
  101.     /**
  102.      * @ORM\ManyToOne(targetEntity="App\Entity\Langue")
  103.      */
  104.     private $langue;
  106.     /**
  107.      * @ORM\Column(type="integer", nullable=true)
  108.      */
  109.     private $uid;
  111.     /**
  112.      * @ORM\OneToMany(targetEntity="App\Entity\Filtre", mappedBy="user")
  113.      */
  114.     private $filtres;
  116.     /**
  117.      * @ORM\OneToMany(targetEntity=UserFilter::class, mappedBy="user")
  118.      */
  119.     private $userFilters;
  121.     /**
  122.      * @ORM\OneToMany(targetEntity=Dossier::class, mappedBy="chargeDossier")
  123.      */
  124.     private $dossiers;
  126.     /**
  127.      * @ORM\OneToMany(targetEntity=Dossier::class, mappedBy="chargeDossier2")
  128.      */
  129.     private $dossiers2;
  131.     /**
  132.      * @ORM\OneToMany(targetEntity=TableauBordRequeteUser::class, mappedBy="user")
  133.      */
  134.     private $tableauBordRequeteUsers;
  136.     /**
  137.      * @ORM\OneToMany(targetEntity=DossierSegmentTodo::class, mappedBy="responsable")
  138.      */
  139.     private $dossierSegmentTodos;
  141.     public function __construct()
  142.     {
  143.         $this->isActive = true;
  144.         $this->logs = new ArrayCollection();
  145.         $this->historiquePages = new ArrayCollection();
  146.         $this->filtres = new ArrayCollection();
  147.         // may not be needed, see section on salt below
  148.         // $this->salt = md5(uniqid('', true));
  150.         $this->userFilters = new ArrayCollection();
  151.         $this->dossiers = new ArrayCollection();
  152.         $this->dossiers2 = new ArrayCollection();
  153.         $this->tableauBordRequeteUsers = new ArrayCollection();
  154.         $this->dossierSegmentTodos = new ArrayCollection();    
  155.     }
  157.     public function __toString()
  158.     {
  159.         return $this->firstname . " " . $this->lastname;
  160.     }
  161.     
  162.     public function getUsername()
  163.     {
  164.         return $this->username;
  165.     }
  167.     public function getSalt()
  168.     {
  169.         // you *may* need a real salt depending on your encoder
  170.         // see section on salt below
  171.         return null;
  172.     }
  174.     public function getPassword()
  175.     {
  176.         return $this->password;
  177.     }
  178.     
  179.     /**
  180.      * @see UserInterface
  181.      */
  182.     public function getRoles(): array
  183.     {
  184.         return array('ROLE_USER', 'ROLE_API');
  185.     }
  187.     public function getRole(): ?Role
  188.     {
  189.         return $this->role;
  190.     }
  192.     public function setRole(?Role $role): self
  193.     {
  194.         $this->role = $role;
  196.         return $this;
  197.     }
  199.     public function eraseCredentials()
  200.     {
  201.     }
  203.     /** @see \Serializable::serialize() */
  204.     public function serialize()
  205.     {
  206.         return serialize(array(
  207.             $this->id,
  208.             $this->username,
  209.             $this->password,
  210.             // see section on salt below
  211.             // $this->salt,
  212.         ));
  213.     }
  215.     /** @see \Serializable::unserialize() */
  216.     public function unserialize($serialized)
  217.     {
  218.         list (
  219.             $this->id,
  220.             $this->username,
  221.             $this->password,
  222.             // see section on salt below
  223.             // $this->salt
  224.         ) = unserialize($serialized);
  225.     }
  227.     public function getFirstname(): ?string
  228.     {
  229.         return $this->firstname;
  230.     }
  232.     public function setFirstname(string $firstname): self
  233.     {
  234.         $this->firstname = $firstname;
  236.         return $this;
  237.     }
  239.     public function getLastname(): ?string
  240.     {
  241.         return $this->lastname;
  242.     }
  244.     public function setLastname(string $lastname): self
  245.     {
  246.         $this->lastname = $lastname;
  248.         return $this;
  249.     }
  251.     public function getId(): ?int
  252.     {
  253.         return $this->id;
  254.     }
  256.     public function setUsername(string $username): self
  257.     {
  258.         $this->username = $username;
  260.         return $this;
  261.     }
  263.     public function setPassword(string $password): self
  264.     {
  265.         $this->password = $password;
  267.         return $this;
  268.     }
  270.     public function getEmail(): ?string
  271.     {
  272.         return $this->email;
  273.     }
  275.     public function setEmail(string $email): self
  276.     {
  277.         $this->email = $email;
  279.         return $this;
  280.     }
  282.     public function getIsActive(): ?bool
  283.     {
  284.         return $this->isActive;
  285.     }
  287.     public function setIsActive(bool $isActive): self
  288.     {
  289.         $this->isActive = $isActive;
  291.         return $this;
  292.     }
  294.     /**
  295.      * @return Collection|Log[]
  296.      */
  297.     public function getLogs(): Collection
  298.     {
  299.         return $this->logs;
  300.     }
  302.     public function addLog(Log $log): self
  303.     {
  304.         if (!$this->logs->contains($log)) {
  305.             $this->logs[] = $log;
  306.             $log->setUserCrea($this);
  307.         }
  309.         return $this;
  310.     }
  312.     public function removeLog(Log $log): self
  313.     {
  314.         if ($this->logs->contains($log)) {
  315.             $this->logs->removeElement($log);
  316.             // set the owning side to null (unless already changed)
  317.             if ($log->getUserCrea() === $this) {
  318.                 $log->setUserCrea(null);
  319.             }
  320.         }
  322.         return $this;
  323.     }
  325.     public function getPhone(): ?string
  326.     {
  327.         return $this->phone;
  328.     }
  330.     public function setPhone(?string $phone): self
  331.     {
  332.         $this->phone = $phone;
  334.         return $this;
  335.     }
  337.     public function getCellphone(): ?string
  338.     {
  339.         return $this->cellphone;
  340.     }
  342.     public function setCellphone(?string $cellphone): self
  343.     {
  344.         $this->cellphone = $cellphone;
  346.         return $this;
  347.     }
  349.     public function getAddress(): ?string
  350.     {
  351.         return $this->address;
  352.     }
  354.     public function setAddress(?string $address): self
  355.     {
  356.         $this->address = $address;
  358.         return $this;
  359.     }
  361.     public function getCity(): ?string
  362.     {
  363.         return $this->city;
  364.     }
  366.     public function setCity(?string $city): self
  367.     {
  368.         $this->city = $city;
  370.         return $this;
  371.     }
  373.     public function getZipcode(): ?string
  374.     {
  375.         return $this->zipcode;
  376.     }
  378.     public function setZipcode(?string $zipcode): self
  379.     {
  380.         $this->zipcode = $zipcode;
  382.         return $this;
  383.     }
  385.     public function getAvatar()
  386.     {
  387.         return $this->avatar;
  388.     }
  390.     public function setAvatar( $avatar): self
  391.     {
  392.         $this->avatar = $avatar;
  394.         return $this;
  395.     }
  397.     /**
  398.      * @return Collection|HistoriquePage[]
  399.      */
  400.     public function getHistoriquePages(): Collection
  401.     {
  402.         return $this->historiquePages;
  403.     }
  405.     public function addHistoriquePage(HistoriquePage $historiquePage): self
  406.     {
  407.         if (!$this->historiquePages->contains($historiquePage)) {
  408.             $this->historiquePages[] = $historiquePage;
  409.             $historiquePage->setUser($this);
  410.         }
  412.         return $this;
  413.     }
  415.     public function removeHistoriquePage(HistoriquePage $historiquePage): self
  416.     {
  417.         if ($this->historiquePages->contains($historiquePage)) {
  418.             $this->historiquePages->removeElement($historiquePage);
  419.             // set the owning side to null (unless already changed)
  420.             if ($historiquePage->getUser() === $this) {
  421.                 $historiquePage->setUser(null);
  422.             }
  423.         }
  425.         return $this;
  426.     }
  428.     public function getLangue(): ?Langue
  429.     {
  430.         return $this->langue;
  431.     }
  433.     public function setLangue(?Langue $langue): self
  434.     {
  435.         $this->langue = $langue;
  437.         return $this;
  438.     }
  439.     
  440.     public function postFlush(PostFlushEventArgs $eventArgs){
  441.             die('test');
  442.     }
  444.     public function getUid(): ?int
  445.     {
  446.         return $this->uid;
  447.     }
  449.     public function setUid(?int $uid): self
  450.     {
  451.         $this->uid = $uid;
  453.         return $this;
  454.     }
  455.     
  456.      /**
  457.      * @return Collection|Filtre[]
  458.      */
  459.     public function getFiltres(): Collection
  460.     {
  461.         return $this->filtres;
  462.     }
  464.     public function addFiltre(Filtre $filtre): self
  465.     {
  466.         if (!$this->filtres->contains($filtre)) {
  467.             $this->filtres[] = $filtre;
  468.             $filtre->setUser($this);
  469.         }
  471.         return $this;
  472.     }
  474.     public function removeFiltre(Filtre $filtre): self
  475.     {
  476.         if ($this->filtres->contains($filtre)) {
  477.             $this->filtres->removeElement($filtre);
  478.             // set the owning side to null (unless already changed)
  479.             if ($filtre->getUser() === $this) {
  480.                 $filtre->setUser(null);
  481.             }
  482.         }
  484.         return $this;
  485.     }
  487.     /**
  488.      * @return Collection|UserFilters[]
  489.      */
  490.     public function getUserFilters(): Collection
  491.     {
  492.         return $this->userFilters;
  493.     }
  495.     public function addUserFilter(UserFilter $userFilter): self
  496.     {
  497.         if (!$this->userFilters->contains($userFilter)) {
  498.             $this->userFilters[] = $userFilter;
  499.             $userFilter->setUser($this);
  500.         }
  502.         return $this;
  503.     }
  505.     public function removeUserFilter(UserFilter $userFilter): self
  506.     {
  507.         if ($this->userFilters->contains($userFilter)) {
  508.             $this->userFilters->removeElement($userFilter);
  509.             // set the owning side to null (unless already changed)
  510.             if ($userFilter->getUser() === $this) {
  511.                 $userFilter->setUser(null);
  512.             }
  513.         }
  515.         return $this;
  516.     }
  518.     /**
  519.      * @return Collection|Dossier[]
  520.      */
  521.     public function getDossiers(): Collection
  522.     {
  523.         return $this->dossiers;
  524.     }
  526.     public function addDossier(Dossier $dossier): self
  527.     {
  528.         if (!$this->dossiers->contains($dossier)) {
  529.             $this->dossiers[] = $dossier;
  530.             $dossier->setChargeDossier($this);
  531.         }
  533.         return $this;
  534.     }
  536.     public function removeDossier(Dossier $dossier): self
  537.     {
  538.         if ($this->dossiers->contains($dossier)) {
  539.             $this->dossiers->removeElement($dossier);
  540.             // set the owning side to null (unless already changed)
  541.             if ($dossier->getChargeDossier() === $this) {
  542.                 $dossier->setChargeDossier(null);
  543.             }
  544.         }
  546.         return $this;
  547.     }
  549.     /**
  550.      * @return Collection|Dossier[]
  551.      */
  552.     public function getDossiers2(): Collection
  553.     {
  554.         return $this->dossiers2;
  555.     }
  557.     public function addDossiers2(Dossier $dossiers2): self
  558.     {
  559.         if (!$this->dossiers2->contains($dossiers2)) {
  560.             $this->dossiers2[] = $dossiers2;
  561.             $dossiers2->setChargeDossier2($this);
  562.         }
  564.         return $this;
  565.     }
  567.     public function removeDossiers2(Dossier $dossiers2): self
  568.     {
  569.         if ($this->dossiers2->contains($dossiers2)) {
  570.             $this->dossiers2->removeElement($dossiers2);
  571.             // set the owning side to null (unless already changed)
  572.             if ($dossiers2->getChargeDossier2() === $this) {
  573.                 $dossiers2->setChargeDossier2(null);
  574.             }
  575.         }
  577.         return $this;
  578.     }
  580.     /**
  581.      * @return Collection|TableauBordRequeteUser[]
  582.      */
  583.     public function getTableauBordRequeteUsers(): Collection
  584.     {
  585.         return $this->tableauBordRequeteUsers;
  586.     }
  588.     public function addTableauBordRequeteUser(TableauBordRequeteUser $tableauBordRequeteUser): self
  589.     {
  590.         if (!$this->tableauBordRequeteUsers->contains($tableauBordRequeteUser)) {
  591.             $this->tableauBordRequeteUsers[] = $tableauBordRequeteUser;
  592.             $tableauBordRequeteUser->setUser($this);
  593.         }
  595.         return $this;
  596.     }
  598.     public function removeTableauBordRequeteUser(TableauBordRequeteUser $tableauBordRequeteUser): self
  599.     {
  600.         if ($this->tableauBordRequeteUsers->contains($tableauBordRequeteUser)) {
  601.             $this->tableauBordRequeteUsers->removeElement($tableauBordRequeteUser);
  602.             // set the owning side to null (unless already changed)
  603.             if ($tableauBordRequeteUser->getUser() === $this) {
  604.                 $tableauBordRequeteUser->setUser(null);
  605.             }
  606.         }
  608.         return $this;
  609.     }
  611.     /**
  612.      * @return Collection|DossierSegmentTodo[]
  613.      */
  614.     public function getDossierSegmentTodos(): Collection
  615.     {
  616.         return $this->dossierSegmentTodos;
  617.     }
  619.     public function addDossierSegmentTodo(DossierSegmentTodo $dossierSegmentTodo): self
  620.     {
  621.         if (!$this->dossierSegmentTodos->contains($dossierSegmentTodo)) {
  622.             $this->dossierSegmentTodos[] = $dossierSegmentTodo;
  623.             $dossierSegmentTodo->setResponsable($this);
  624.         }
  626.         return $this;
  627.     }
  629.     public function removeDossierSegmentTodo(DossierSegmentTodo $dossierSegmentTodo): self
  630.     {
  631.         if ($this->dossierSegmentTodos->contains($dossierSegmentTodo)) {
  632.             $this->dossierSegmentTodos->removeElement($dossierSegmentTodo);
  633.             // set the owning side to null (unless already changed)
  634.             if ($dossierSegmentTodo->getResponsable() === $this) {
  635.                 $dossierSegmentTodo->setResponsable(null);
  636.             }
  637.         }
  639.         return $this;
  640.     }
  641. }
  643. ?>