src/Entity/User.php line 22

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Carbon\Carbon;
  7. use DateTime;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Doctrine\ORM\Mapping\HasLifecycleCallbacks;
  12. use Doctrine\ORM\Mapping\PrePersist;
  13. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  14. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  15. use Symfony\Component\Security\Core\User\UserInterface;
  16. use Symfony\Component\Serializer\Annotation\Groups;
  17. use Symfony\Component\Validator\Constraints as Assert;
  19. #[ORM\Entity(repositoryClass: UserRepository::class)]
  20. #[HasLifecycleCallbacks]
  21. #[UniqueEntity('username', message: 'Ce compte existe déjà. Veuillez utiliser une autre adresse email ou vous connecter.')]
  22. class User implements UserInterface, PasswordAuthenticatedUserInterface
  23. {
  24.     #[ORM\Id]
  25.     #[ORM\GeneratedValue]
  26.     #[ORM\Column]
  27.     #[Groups(["list_recipes", "user_info","show_recipe", "show_course", "comment_list", "show_subscription", "show_recipe_count"])]
  28.     private ?int $id = null;
  30.     #[ORM\Column(length: 180, unique: true)]
  31.     #[Assert\NotBlank(message: 'Champ mot de passe est requis')]
  32.     #[Groups(["show_course", "comment_list", "list_recipes", "show_recipe", "user_info", "show_subscription", "show_order", "show_recipe_count"])]
  33.     private ?string $email = null;
  35.     #[ORM\Column]
  36.     private array $roles = [];
  38.     /**
  39.      * @var string The hashed password
  40.      */
  41.     #[Assert\NotBlank(message: 'Champ mot de passe est requis')]
  42.     #[Assert\Length(min: 8, minMessage: 'Le mot de passe doit contenir au moins 8 caratères')]
  43.     #[ORM\Column]
  44.     private ?string $password = null;
  46.     #[Assert\NotBlank(message: 'Le champ Nom est requis')]
  47.     #[ORM\Column(length: 255, nullable: true)]
  48.     #[Groups(["show_course", "comment_list", "list_recipes", "show_recipe", "user_info", "show_subscription", "show_order", "show_restaurant"])]
  49.     private ?string $nom = null;
  51.     #[Assert\NotBlank(message: 'Le champ Prénom(s) est requis')]
  52.     #[ORM\Column(length: 255, nullable: true)]
  53.     #[Groups(["show_course", "comment_list", "list_recipes", "show_recipe", "user_info", "show_subscription", "show_order", "show_restaurant"])]
  54.     private ?string $prenoms = null;
  56.     #[Assert\NotBlank(message: 'Le champ email est requis')]
  57.     #[Groups(["user_info"])]
  58.     #[ORM\Column(length: 255, nullable: true, unique: true)]
  59.     private ?string $username = null;
  61.     #[ORM\Column(length: 255, nullable: true)]
  62.     private ?string $birthday = null;
  64.     #[ORM\Column(length: 255, nullable: true)]
  65.     #[Groups(["show_course", "comment_list", "list_recipes", "show_recipe", "user_info"])]
  66.     private ?string $adresse = null;
  68.     #[ORM\Column(length: 255, nullable: true)]
  69.     #[Groups(["show_course", "comment_list", "list_recipes", "show_recipe", "user_info"])]
  70.     private ?string $ville = null;
  72.     // #[Assert\NotBlank(message: 'Ce champ est requis')]
  73.     #[Groups(["user_info"])]
  74.     #[ORM\Column(length: 255, nullable: true)]
  75.     private ?string $dial_code = null;
  77.     #[Assert\NotBlank(message: 'Le Numéro de télépone est requis')]
  78.     #[Groups(["user_info", "show_order", "show_subscription", "show_course"])]
  79.     #[ORM\Column(length: 255)]
  80.     private ?string $numero = null;
  82.     #[ORM\Column(length: 255, nullable: true)]
  83.     private ?string $code_pays = null;
  85.     #[ORM\Column(length: 255, nullable: true)]
  86.     private ?DateTime  $password_requested_at = null;
  88.     #[ORM\Column(length: 255, nullable: true)]
  89.     private ?string $token = null;
  91.     #[ORM\Column(length: 255, nullable: true)]
  92.     private ?string $pays = null;
  94.     #[ORM\Column(length: 255, nullable: true)]
  95.     private ?string $lien_facebook = null;
  97.     #[ORM\Column(length: 255, nullable: true)]
  98.     private ?string $nom_complet = null;
  100.     #[ORM\Column(length: 255, nullable: true)]
  101.     private ?string $lien_site_web = null;
  103.     #[ORM\Column(length: 255, nullable: true)]
  104.     private ?string $type_compte = null;
  106.     #[ORM\Column(length: 255, nullable: true)]
  107.     private ?bool $actif = null;
  109.     #[ORM\Column(length: 255, nullable: true)]
  110.     private ?bool $email_verified = null;
  112.     #[ORM\Column(nullable: true, options: ["default" => 0])]
  113.     #[Groups(["user_info", "list_recipes"])]
  114.     private ?bool $is_cooker = null;
  116.     #[ORM\Column(nullable: true, options: ["default" => 0])]
  117.     #[Groups(["user_info"])]
  118.     private ?bool $is_admin = null;
  120.     #[ORM\Column(options: ["default" => 0], nullable: true)]
  121.     private ?bool $has_restaurant = null;
  123.     #[Groups(["user_info", "show_restaurant"])]
  124.     private $checkSubscriptionTime;
  126.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Course::class)]
  127.     #[Groups(["user_info"])]
  128.     private Collection $courses;
  130.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Restaurant::class)]
  131.     #[Groups(["user_info"])]
  132.     private Collection $restaurants;
  134.     #[Groups(["user_info", "list_recipes", "show_recipe", "show_course", "list_courses"])]
  135.     #[ORM\Column(length: 255, nullable: true, options: ["default" => "https://i.imgur.com/zCL2LAh.png"])]
  136.     private ?string $photo = null;
  137.    
  138.     #[Groups(["for_abj"])]
  139.     private ?string $photoFullPath = null;
  140.    
  141.     #[Groups(["for_abj"])]
  142.     private ?string $profilFullPath = null;
  144.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Order::class)]
  145.     #[Groups(["user_info"])]
  146.     private Collection $orders;
  148.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Shop::class)]
  149.     private Collection $shops;
  151.     #[ORM\ManyToMany(targetEntity: Subscription::class, mappedBy: 'subscriber')]
  152.     #[Groups(["user_info"])]
  153.     #[ORM\JoinColumn(referencedColumnName: 'subscription_id', nullable: true, onDelete: "CASCADE")]
  154.     private Collection $subscriptions;
  156.     #[Groups(['user_info'])]
  157.     private $currentSubscription = [];
  159.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: CookingTricks::class)]
  160.     #[Groups(["user_info"])]
  161.     private Collection $cookingTricks;
  163.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Recipe::class)]
  164.     #[Groups(["user_info"])]
  165.     private Collection $recipes;
  167.     #[ORM\OneToMany(mappedBy: 'liker', targetEntity: Like::class)]
  168.     #[Groups(["user_info"])]
  169.     private Collection $likes;
  171.     #[ORM\ManyToMany(targetEntity: BookMaker::class, mappedBy: 'saver')]
  172.     #[Groups(["user_info"])]
  173.     private Collection $bookMakers;
  175.     #[ORM\ManyToMany(targetEntity: Rate::class, mappedBy: 'user')]
  176.     private Collection $rates;
  178.     #[ORM\ManyToMany(targetEntity: RateRestaurant::class, mappedBy: 'user')]
  179.     private Collection $rateRestaurants;
  181.     #[ORM\OneToMany(mappedBy: 'publisher', targetEntity: Course::class)]
  182.     #[Groups(["user_info"])]
  183.     private Collection $cookingCourses;
  185.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Transactions::class)]
  186.     private Collection $transactions;
  188.     #[ORM\ManyToMany(targetEntity: RecipeCount::class, mappedBy: 'visitor')]
  189.     private Collection $recipeCounts;
  191.     #[ORM\Column(type: "datetime", nullable: true)]
  192.     #[Groups(["list_recipes", "user_info", "show_recipe", "show_order", "comment_list"])]
  193.     private \DateTimeInterface $date_creation;
  195.     #[ORM\Column(type: "datetime", nullable: true)]
  196.     #[Groups(["list_recipes", "user_info", "show_recipe", "show_order", "comment_list"])]
  197.     private ?\DateTimeInterface $date_modification;
  199.     #[ORM\Column(type: "datetime", nullable: true)]
  200.     #[Groups(["list_recipes", "user_info", "show_recipe", "show_order", "comment_list"])]
  201.     private ?\DateTimeInterface $date_suppression;
  203.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserSessions::class)]
  204.     private Collection $userSessions;
  206.     #[ORM\ManyToMany(targetEntity: CourseParticipants::class, mappedBy: 'participants')]
  207.     private Collection $courseParticipants;
  209.     // use Timestapable;
  210.     // use base64Field;
  212.     public function __construct()
  213.     {
  214.         $this->courses = new ArrayCollection();
  215.         $this->restaurants = new ArrayCollection();
  216.         $this->orders = new ArrayCollection();
  217.         $this->shops = new ArrayCollection();
  218.         $this->subscriptions = new ArrayCollection();
  219.         $this->cookingTricks = new ArrayCollection();
  220.         $this->recipes = new ArrayCollection();
  221.         $this->likes = new ArrayCollection();
  222.         $this->bookMakers = new ArrayCollection();
  223.         // $this->rates = new ArrayCollection();
  224.         // $this->rateRestaurants = new ArrayCollection();
  225.         $this->cookingCourses = new ArrayCollection();
  226.         $this->transactions = new ArrayCollection();
  227.         $this->recipeCounts = new ArrayCollection();
  228.         $this->userSessions = new ArrayCollection();
  229.         $this->courseParticipants = new ArrayCollection();
  230.     }
  233.     public function getId(): ?int
  234.     {
  235.         return $this->id;
  236.     }
  238.     public function getEmail(): ?string
  239.     {
  240.         return $this->email;
  241.     }
  243.     public function setEmail(string $email): self
  244.     {
  245.         $this->email = $email;
  247.         return $this;
  248.     }
  250.     /**
  251.      * A visual identifier that represents this user.
  252.      *
  253.      * @see UserInterface   
  254.      */
  255.     public function getUserIdentifier(): string
  256.     {
  257.         // return (string) $this->username;
  258.         return (string) $this->email;
  259.     }
  261.     /**
  262.      * @see UserInterface
  263.      */
  264.     public function getRoles(): array
  265.     {
  266.         $roles = $this->roles;
  267.         // guarantee every user at least has ROLE_USER
  268.         $roles[] = 'ROLE_USER';
  270.         return array_unique($roles);
  271.     }
  273.     public function setRoles(array $roles): self
  274.     {
  275.         $this->roles = $roles;
  277.         return $this;
  278.     }
  280.     /**
  281.      * @see PasswordAuthenticatedUserInterface
  282.      */
  283.     public function getPassword(): string
  284.     {
  285.         return $this->password;
  286.     }
  288.     public function setPassword(string $password): self
  289.     {
  290.         $this->password = $password;
  292.         return $this;
  293.     }
  295.     /**
  296.      * @see UserInterface
  297.      */
  298.     public function eraseCredentials()
  299.     {
  300.         // If you store any temporary, sensitive data on the user, clear it here
  301.         // $this->plainPassword = $this->password;
  302.     }
  304.     // public function getSpeudo(): ?string
  305.     // {
  306.     //     return $this->speudo;
  307.     // }
  309.     // public function setSpeudo(string $speudo): self
  310.     // {
  311.     //     $this->speudo = $speudo;
  313.     //     return $this;
  314.     // }
  317.     public function getBirthday(): ?string
  318.     {
  319.         return $this->birthday;
  320.     }
  322.     public function setBirthday(?string $birthday): self
  323.     {
  324.         $this->birthday = $birthday;
  326.         return $this;
  327.     }
  330.     public function getDialCode(): ?string
  331.     {
  332.         return $this->dial_code;
  333.     }
  335.     public function setDialCode(?string $dial_code): self
  336.     {
  337.         $this->dial_code = $dial_code;
  339.         return $this;
  340.     }
  342.     public function isIsCooker(): ?bool
  343.     {
  344.         return $this->is_cooker;
  345.     }
  347.     public function setIsCooker(?bool $is_cooker): self
  348.     {
  349.         $this->is_cooker = $is_cooker;
  351.         return $this;
  352.     }
  354.     public function isHasRestaurant(): ?bool
  355.     {
  356.         return $this->has_restaurant;
  357.     }
  359.     public function setHasRestaurant(?bool $has_restaurant): self
  360.     {
  361.         $this->has_restaurant = $has_restaurant;
  363.         return $this;
  364.     }
  366.     /**
  367.      * @return Collection<int, Course>
  368.      */
  369.     public function getCourses(): Collection
  370.     {
  371.         return $this->courses;
  372.     }
  374.     public function addCourse(Course $course): self
  375.     {
  376.         if (!$this->courses->contains($course)) {
  377.             $this->courses->add($course);
  378.             $course->setUser($this);
  379.         }
  381.         return $this;
  382.     }
  384.     public function removeCourse(Course $course): self
  385.     {
  386.         if ($this->courses->removeElement($course)) {
  387.             // set the owning side to null (unless already changed)
  388.             if ($course->getUser() === $this) {
  389.                 $course->setUser(null);
  390.             }
  391.         }
  393.         return $this;
  394.     }
  396.     /**
  397.      * @return Collection<int, Restaurant>
  398.      */
  399.     public function getRestaurants(): Collection
  400.     {
  401.         return $this->restaurants;
  402.     }
  404.     public function addRestaurant(Restaurant $restaurant): self
  405.     {
  406.         if (!$this->restaurants->contains($restaurant)) {
  407.             $this->restaurants->add($restaurant);
  408.             $restaurant->setOwner($this);
  409.         }
  411.         return $this;
  412.     }
  414.     public function removeRestaurant(Restaurant $restaurant): self
  415.     {
  416.         if ($this->restaurants->removeElement($restaurant)) {
  417.             // set the owning side to null (unless already changed)
  418.             if ($restaurant->getOwner() === $this) {
  419.                 $restaurant->setOwner(null);
  420.             }
  421.         }
  423.         return $this;
  424.     }
  427.     /**
  428.      * @return Collection<int, Order>
  429.      */
  430.     public function getOrders(): Collection
  431.     {
  432.         return $this->orders;
  433.     }
  435.     public function addOrder(Order $order): self
  436.     {
  437.         if (!$this->orders->contains($order)) {
  438.             $this->orders->add($order);
  439.             $order->setUser($this);
  440.         }
  442.         return $this;
  443.     }
  445.     public function removeOrder(Order $order): self
  446.     {
  447.         if ($this->orders->removeElement($order)) {
  448.             // set the owning side to null (unless already changed)
  449.             if ($order->getUser() === $this) {
  450.                 $order->setUser(null);
  451.             }
  452.         }
  454.         return $this;
  455.     }
  457.     /**
  458.      * @return Collection<int, Shop>
  459.      */
  460.     public function getShops(): Collection
  461.     {
  462.         return $this->shops;
  463.     }
  465.     public function addShop(Shop $shop): self
  466.     {
  467.         if (!$this->shops->contains($shop)) {
  468.             $this->shops->add($shop);
  469.             $shop->setOwner($this);
  470.         }
  472.         return $this;
  473.     }
  475.     public function removeShop(Shop $shop): self
  476.     {
  477.         if ($this->shops->removeElement($shop)) {
  478.             // set the owning side to null (unless already changed)
  479.             if ($shop->getOwner() === $this) {
  480.                 $shop->setOwner(null);
  481.             }
  482.         }
  484.         return $this;
  485.     }
  487.     /**
  488.      * @return Collection<int, Subscription>
  489.      */
  490.     public function getSubscriptions(): Collection
  491.     {
  492.         $sub = $this->subscriptions->filter(
  493.             function ($subscription) {
  494.                 if ($subscription?->getSubscriptionType()?->getTitle() != "cooker") {
  495.                     return true;
  496.                 }
  497.             }
  498.         );
  500.         return $sub;
  501.     }
  503.     public function addSubscription(Subscription $subscription): self
  504.     {
  505.         if (!$this->subscriptions->contains($subscription)) {
  506.             $this->subscriptions->add($subscription);
  507.             $subscription->addSubscriber($this);
  508.         }
  510.         return $this;
  511.     }
  513.     public function removeSubscription(Subscription $subscription): self
  514.     {
  515.         if ($this->subscriptions->removeElement($subscription)) {
  516.             $subscription->removeSubscriber($this);
  517.         }
  519.         return $this;
  520.     }
  522.     /**
  523.      * @return Collection<int, CookingTricks>
  524.      */
  525.     public function getCookingTricks(): Collection
  526.     {
  527.         return $this->cookingTricks;
  528.     }
  530.     public function addCookingTrick(CookingTricks $cookingTrick): self
  531.     {
  532.         if (!$this->cookingTricks->contains($cookingTrick)) {
  533.             $this->cookingTricks->add($cookingTrick);
  534.             $cookingTrick->setUser($this);
  535.         }
  537.         return $this;
  538.     }
  540.     public function removeCookingTrick(CookingTricks $cookingTrick): self
  541.     {
  542.         if ($this->cookingTricks->removeElement($cookingTrick)) {
  543.             // set the owning side to null (unless already changed)
  544.             if ($cookingTrick->getUser() === $this) {
  545.                 $cookingTrick->setUser(null);
  546.             }
  547.         }
  549.         return $this;
  550.     }
  553.     /**
  554.      * Get the value of username
  555.      */
  556.     public function getUsername()
  557.     {
  558.         return $this->username;
  559.     }
  561.     /**
  562.      * Set the value of username
  563.      *
  564.      * @return  self
  565.      */
  566.     public function setUsername($username)
  567.     {
  568.         $this->username = $username;
  570.         return $this;
  571.     }
  573.     /**
  574.      * @return Collection<int, Recipe>
  575.      */
  576.     public function getRecipes()
  577.     {
  578.         return $this->recipes;
  579.     }
  581.     public function addRecipe(Recipe $recipe): self
  582.     {
  583.         if (!$this->recipes->contains($recipe)) {
  584.             $this->recipes->add($recipe);
  585.             $recipe->setUser($this);
  586.         }
  588.         return $this;
  589.     }
  591.     public function removeRecipe(Recipe $recipe): self
  592.     {
  593.         if ($this->recipes->removeElement($recipe)) {
  594.             // set the owning side to null (unless already changed)
  595.             if ($recipe->getUser() === $this) {
  596.                 $recipe->setUser(null);
  597.             }
  598.         }
  600.         return $this;
  601.     }
  604.     /**
  605.      * @return Collection<int, Like>
  606.      */
  607.     public function getLikes($need = false)
  608.     {
  609.         if ($need == true) {
  610.             return $this->likes;
  611.         }
  613.         return null;
  614.     }
  616.     public function addLike(Like $like): self
  617.     {
  618.         if (!$this->likes->contains($like)) {
  619.             $this->likes->add($like);
  620.             $like->setLiker($this);
  621.         }
  623.         return $this;
  624.     }
  626.     public function removeLike(Like $like): self
  627.     {
  628.         if ($this->likes->removeElement($like)) {
  629.             // set the owning side to null (unless already changed)
  630.             if ($like->getLiker() === $this) {
  631.                 $like->setLiker(null);
  632.             }
  633.         }
  635.         return $this;
  636.     }
  638.     /**
  639.      * @return Collection<int, BookMaker>
  640.      */
  641.     public function getBookMakers()
  642.     {
  643.         return $this->bookMakers;
  644.     }
  646.     public function addBookMaker(BookMaker $bookMaker): self
  647.     {
  648.         if (!$this->bookMakers->contains($bookMaker)) {
  649.             $this->bookMakers->add($bookMaker);
  650.             $bookMaker->addSaver($this);
  651.         }
  653.         return $this;
  654.     }
  656.     public function removeBookMaker(BookMaker $bookMaker): self
  657.     {
  658.         if ($this->bookMakers->removeElement($bookMaker)) {
  659.             $bookMaker->removeSaver($this);
  660.         }
  662.         return $this;
  663.     }
  665.     /**
  666.      * @return Collection<int, Course>
  667.      */
  668.     public function getCookingCourses(): Collection
  669.     {
  670.         return $this->cookingCourses;
  671.     }
  673.     public function addCookingCourse(Course $cookingCourse): self
  674.     {
  675.         if (!$this->cookingCourses->contains($cookingCourse)) {
  676.             $this->cookingCourses->add($cookingCourse);
  677.             $cookingCourse->setPublisher($this);
  678.         }
  680.         return $this;
  681.     }
  683.     public function removeCookingCourse(Course $cookingCourse): self
  684.     {
  685.         if ($this->cookingCourses->removeElement($cookingCourse)) {
  686.             // set the owning side to null (unless already changed)
  687.             if ($cookingCourse->getPublisher() === $this) {
  688.                 $cookingCourse->setPublisher(null);
  689.             }
  690.         }
  692.         return $this;
  693.     }
  696.     public function getCurrentSubscription()
  697.     {
  698.         $this->currentSubscription = $this->getSubscriptions();
  700.         if (empty($this->currentSubscription)) {
  701.             return [];
  702.         } else {
  704.             $subscriptionPaid = $this->getSubscriptions()->filter(
  705.                 function ($value) {
  706.                     $endDate = $value->getEndDate();
  707.                     if (!(Carbon::parse($endDate)->isPast())) {
  708.                         if ($value->getCommande() != null) {
  709.                             if ($value->getCommande()->isIsPaid() == true) {
  710.                                 return true;
  711.                             }
  712.                         }
  713.                     }
  714.                 }
  715.             );
  717.             return $subscriptionPaid->last();
  718.         }
  719.     }
  721.     public function getCheckSubscriptionTime()
  722.     {
  723.         $current = $this->getCurrentSubscription();
  725.         if(!empty($current)){
  726.             if ($current->getCommande()?->isIsPaid() ==  true) {
  727.                 return true;
  728.             }
  729.         }
  731.         if (!empty($this->getSubscriptions()?->last())) {
  733.             if ($this->getSubscriptions()?->last()->getCommande()?->isIsPaid() ==  true) {
  735.                 $startDate = Carbon::parse($this->getSubscriptions()?->last()?->getStartDate());
  736.                 $endDate = Carbon::parse($this->getSubscriptions()?->last()?->getEndDate());
  738.                 $check = Carbon::now()->between($startDate, $endDate);
  739.             } else {
  740.                 $check = false;
  741.             }
  744.             if ($check) {
  745.                 return true;
  746.             } else {
  747.                 return false;
  748.             }
  749.         }
  751.         return false;
  752.     }
  754.     /* 
  755.     public function getActifSubscriptions()
  756.     {
  757.     $subscriptionList = $this->getSubscriptions();
  759.     $subscriptionList->filter( function ($sub) {
  760.         if($sub->getCommande()->){
  762.         }
  763.     });
  765. } 
  766.     */
  768.     /**
  769.      * @return Collection<int, Transactions>
  770.      */
  771.     public function getTransactions(): Collection
  772.     {
  773.         return $this->transactions;
  774.     }
  776.     public function addTransaction(Transactions $transaction): self
  777.     {
  778.         if (!$this->transactions->contains($transaction)) {
  779.             $this->transactions->add($transaction);
  780.             $transaction->setUser($this);
  781.         }
  783.         return $this;
  784.     }
  786.     public function removeTransaction(Transactions $transaction): self
  787.     {
  788.         if ($this->transactions->removeElement($transaction)) {
  789.             // set the owning side to null (unless already changed)
  790.             if ($transaction->getUser() === $this) {
  791.                 $transaction->setUser(null);
  792.             }
  793.         }
  795.         return $this;
  796.     }
  798.     /**
  799.      * @return Collection<int, RecipeCount>
  800.      */
  801.     public function getRecipeCounts(): Collection
  802.     {
  803.         return $this->recipeCounts;
  804.     }
  806.     public function addRecipeCount(RecipeCount $recipeCount): self
  807.     {
  808.         if (!$this->recipeCounts->contains($recipeCount)) {
  809.             $this->recipeCounts->add($recipeCount);
  810.             $recipeCount->addVisitor($this);
  811.         }
  813.         return $this;
  814.     }
  816.     public function removeRecipeCount(RecipeCount $recipeCount): self
  817.     {
  818.         if ($this->recipeCounts->removeElement($recipeCount)) {
  819.             $recipeCount->removeVisitor($this);
  820.         }
  822.         return $this;
  823.     }
  825.     public function getNom()
  826.     {
  827.         return $this->nom;
  828.     }
  830.     public function setNom($nom)
  831.     {
  832.         $this->nom = $nom;
  834.         return $this;
  835.     }
  837.     public function getPrenoms()
  838.     {
  839.         return $this->prenoms;
  840.     }
  842.     public function setPrenoms($prenoms)
  843.     {
  844.         $this->prenoms = $prenoms;
  846.         return $this;
  847.     }
  849.     public function getAdresse()
  850.     {
  851.         return $this->adresse;
  852.     }
  854.     public function setAdresse($adresse)
  855.     {
  856.         $this->adresse = $adresse;
  858.         return $this;
  859.     }
  861.     public function getVille()
  862.     {
  863.         return $this->ville;
  864.     }
  866.     public function setVille($ville)
  867.     {
  868.         $this->ville = $ville;
  870.         return $this;
  871.     }
  873.     public function getNumero()
  874.     {
  875.         return $this->numero;
  876.     }
  878.     public function setNumero($numero)
  879.     {
  880.         $this->numero = $numero;
  882.         return $this;
  883.     }
  885.     public function getCodePays()
  886.     {
  887.         return $this->code_pays;
  888.     }
  890.     public function setCodePays($code_pays)
  891.     {
  892.         $this->code_pays = $code_pays;
  894.         return $this;
  895.     }
  897.     public function getPays()
  898.     {
  899.         return $this->pays;
  900.     }
  902.     public function setPays($pays)
  903.     {
  904.         $this->pays = $pays;
  906.         return $this;
  907.     }
  909.     public function getDateCreation()
  910.     {
  911.         return $this->date_creation;
  912.     }
  914.     public function setDateCreation($date_creation)
  915.     {
  916.         $this->date_creation = $date_creation;
  918.         return $this;
  919.     }
  921.     #[PrePersist]
  922.     public function saveDateCreation()
  923.     {
  924.         $this->setDateCreation(new \DateTimeImmutable());
  925.         $this->setDateModification(new \DateTimeImmutable());
  926.     }
  928.     public function getDateModification()
  929.     {
  930.         return $this->date_modification;
  931.     }
  933.     public function setDateModification($date_modification)
  934.     {
  935.         $this->date_modification = $date_modification;
  937.         return $this;
  938.     }
  941.     public function getDateSuppression()
  942.     {
  943.         return $this->date_suppression;
  944.     }
  946.     /**
  947.      * Get the value of is_admin
  948.      */
  949.     public function getIsAdmin()
  950.     {
  951.         return $this->is_admin;
  952.     }
  954.     /**
  955.      * @return Collection<int, UserSessions>
  956.      */
  957.     public function getUserSessions(): Collection
  958.     {
  959.         return $this->userSessions;
  960.     }
  962.     public function addUserSession(UserSessions $userSession): self
  963.     {
  964.         if (!$this->userSessions->contains($userSession)) {
  965.             $this->userSessions->add($userSession);
  966.             $userSession->setUser($this);
  967.         }
  969.         return $this;
  970.     }
  972.     public function removeUserSession(UserSessions $userSession): self
  973.     {
  974.         if ($this->userSessions->removeElement($userSession)) {
  975.             // set the owning side to null (unless already changed)
  976.             if ($userSession->getUser() === $this) {
  977.                 $userSession->setUser(null);
  978.             }
  979.         }
  981.         return $this;
  982.     }
  984.     public function getType_compte()
  985.     {
  986.         return $this->type_compte;
  987.     }
  990.     public function setType_compte($type_compte)
  991.     {
  992.         $this->type_compte = $type_compte;
  994.         return $this;
  995.     }
  997.     public function getNomComplet()
  998.     {
  999.         return $this->nom_complet;
  1000.     }
  1003.     public function setNomComplet($nom_complet)
  1004.     {
  1005.         $this->nom_complet = $nom_complet;
  1007.         return $this;
  1008.     }
  1011.     public function setIsAdmin($is_admin)
  1012.     {
  1013.         $this->is_admin = $is_admin;
  1015.         return $this;
  1016.     }
  1018.     public function getTypeCompte()
  1019.     {
  1020.         return $this->type_compte;
  1021.     }
  1023.     public function setTypeCompte($type_compte)
  1024.     {
  1025.         $this->type_compte = $type_compte;
  1026.         return $this;
  1027.     }
  1029.     public function setToken($token)
  1030.     {
  1031.         $this->token = $token;
  1032.         return $this;
  1033.     }
  1035.     public function getToken()
  1036.     {
  1037.         return $this->token;
  1038.     }
  1040.     public function setPasswordRequestedAt($date)
  1041.     {
  1042.         $this->password_requested_at = $date;
  1043.     }
  1045.     public function getPasswordRequestedAt()
  1046.     {
  1047.         return $this->password_requested_at;
  1048.     }
  1050.     /**
  1051.      * @return Collection<int, CourseParticipants>
  1052.      */
  1053.     public function getCourseParticipants(): Collection
  1054.     {
  1055.         return $this->courseParticipants;
  1056.     }
  1058.     public function addCourseParticipant(CourseParticipants $courseParticipant): self
  1059.     {
  1060.         if (!$this->courseParticipants->contains($courseParticipant)) {
  1061.             $this->courseParticipants->add($courseParticipant);
  1062.             $courseParticipant->addParticipant($this);
  1063.         }
  1065.         return $this;
  1066.     }
  1068.     public function removeCourseParticipant(CourseParticipants $courseParticipant): self
  1069.     {
  1070.         if ($this->courseParticipants->removeElement($courseParticipant)) {
  1071.             $courseParticipant->removeParticipant($this);
  1072.         }
  1074.         return $this;
  1075.     }
  1077.     public function setEmailVerified($email_verified)
  1078.     {
  1079.         $this->email_verified = $email_verified;
  1081.         return $this;
  1082.     }
  1084.     public function getPhoto()
  1085.     {
  1086.         return $this->photo;
  1087.     }
  1089.     public function getPhotoFullPath()
  1090.     {
  1091.         if(str_contains($this->photoFullPath, "images/")){
  1092.             $baseUrl = "https://cuisine.abidjan.net";
  1093.             return "$baseUrl/".$this->photoFullPath;
  1094.         }
  1096.         return "https://i.imgur.com/zCL2LAh.png";
  1097.     }
  1099.     public function setPhoto($photo)
  1100.     {
  1101.         $this->photo = $photo;
  1102.         return $this;
  1103.     }
  1105.     public function getActif()
  1106.     {
  1107.         return $this->actif;
  1108.     }
  1110.     public function setActif($actif)
  1111.     {
  1112.         $this->actif = $actif;
  1114.         return $this;
  1115.     }
  1117.     public function getEmailVerified()
  1118.     {
  1119.         return $this->email_verified;
  1120.     }
  1122.     public function getProfilFullPath()
  1123.     {
  1124.         $baseUrl = "https://cuisine.abidjan.net";
  1125.         $profilPath = "$baseUrl/"."profil-utilisateur/".$this->id;
  1127.         $this->profilFullPath= $profilPath;
  1128.         return $this->profilFullPath;
  1129.     }
  1130. }