src/Entity/User.php line 40

  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Symfony\Component\Uid\Ulid;
  8. use App\Controller\Auth\MeController;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use App\Repository\UserRepository;
  11. use ApiPlatform\Core\Annotation\ApiResource;
  12. use Symfony\Component\Serializer\Annotation\Groups;
  13. use Symfony\Bridge\Doctrine\IdGenerator\UlidGenerator;
  14. use Symfony\Component\Security\Core\User\UserInterface;
  15. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  16. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  17. use Gedmo\Mapping\Annotation as Gedmo;
  19. #[ORM\Entity(repositoryClass: UserRepository::class)]
  20. #[Gedmo\SoftDeleteable(fieldName: 'deletedAt', timeAware: false, hardDelete: true)]
  21. #[ORM\Table(name: '`user`')]
  22. #[ORM\HasLifecycleCallbacks()]
  23. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  24. #[ApiResource(
  25.     normalizationContext: [
  26.         'groups' => ['read:user']
  27.     ],
  28.     collectionOperations: [],
  29.     itemOperations: [
  30.         'me' => [
  31.             'pagination_enabled' => false,
  32.             'path' => '/me',
  33.             'method' => 'get',
  34.             'requirements' => [],
  35.             'controller' => MeController::class,
  36.             'read' => false,
  37.         ]
  38.     ]
  39. )]
  40. class User implements UserInterface, PasswordAuthenticatedUserInterface
  41. {
  42.     use Timestamps;
  44.     #[ORM\Id]
  45.     #[ORM\Column(type: 'ulid', unique: true)]
  46.     #[ORM\GeneratedValue(strategy: "CUSTOM")]
  47.     #[ORM\CustomIdGenerator(class: UlidGenerator::class)]
  48.     #[Groups(['read:user', 'read:user:profile'])]
  49.     private ?Ulid $id = null;
  51.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  52.     #[Groups(['read:user'])]
  53.     private $email;
  55.     #[ORM\Column(type: 'json')]
  56.     #[Groups(['read:user'])]
  57.     private $roles = [];
  59.     #[ORM\Column(type: 'string')]
  60.     private $password;
  62.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  63.     #[Groups(['read:user'])]
  64.     private $first_name;
  66.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  67.     #[Groups(['read:user'])]
  68.     private $last_name;
  70.     #[ORM\Column(type: 'boolean')]
  71.     #[Groups(['read:user'])]
  72.     private $isVerified = false;
  74.     #[ORM\ManyToOne(targetEntity: Company::class, inversedBy: 'users')]
  75.     private $company;
  77.     #[ORM\OneToMany(mappedBy: 'customer', targetEntity: Order::class, orphanRemoval: true)]
  78.     private $orders;
  80.     #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: Subscription::class, orphanRemoval: true)]
  81.     private $subscriptions;
  83.     #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: Payment::class, orphanRemoval: true)]
  84.     private $payments;
  86.     #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: Post::class, orphanRemoval: true)]
  87.     private $posts;
  89.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  90.     #[Groups(['read:user'])]
  91.     private $photo;
  93.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  94.     private $google_id;
  96.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  97.     private $facebook_id;
  99.     #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: Pointing::class, orphanRemoval: true)]
  100.     private $pointings;
  102.     #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: AbsenceEmployee::class, orphanRemoval: true)]
  103.     private $absenceEmployees;
  105.     #[ORM\Column(type: 'datetime', nullable: true)]
  106.     private $last_login;
  108.     #[ORM\OneToMany(mappedBy: 'made_by', targetEntity: Activity::class)]
  109.     private Collection $activities;
  111.     #[ORM\Column(length: 255, nullable: true)]
  112.     private ?string $phone = null;
  114.     #[ORM\Column(nullable: true)]
  115.     private ?bool $isActive = true;
  117.     public function __construct()
  118.     {
  119.         $this->orders = new ArrayCollection();
  120.         $this->subscriptions = new ArrayCollection();
  121.         $this->payments = new ArrayCollection();
  122.         $this->posts = new ArrayCollection();
  123.         $this->pointings = new ArrayCollection();
  124.         $this->absenceEmployees = new ArrayCollection();
  125.         $this->activities = new ArrayCollection();
  126.     }
  128.     public function __toString()
  129.     {
  130.         return $this->first_name . " " . $this->last_name;
  131.     }
  133.     public function getId(): ?Ulid
  134.     {
  135.         return $this->id;
  136.     }
  138.     public function getEmail(): ?string
  139.     {
  140.         return $this->email;
  141.     }
  143.     public function setEmail(string $email): self
  144.     {
  145.         $this->email = $email;
  147.         return $this;
  148.     }
  150.     /**
  151.      * A visual identifier that represents this user.
  152.      *
  153.      * @see UserInterface
  154.      */
  155.     public function getUserIdentifier(): string
  156.     {
  157.         return (string) $this->email;
  158.     }
  160.     /**
  161.      * @see UserInterface
  162.      */
  163.     public function getRoles(): array
  164.     {
  165.         $roles = $this->roles;
  166.         // guarantee every user at least has ROLE_USER
  167.         $roles[] = 'ROLE_USER';
  169.         return array_unique($roles);
  170.     }
  172.     public function setRoles(array $roles): self
  173.     {
  174.         $this->roles = $roles;
  176.         return $this;
  177.     }
  179.     public function addRole(string $roles): self
  180.     {
  181.         $this->roles[] = $roles;
  183.         return $this;
  184.     }
  186.     /**
  187.      * @see PasswordAuthenticatedUserInterface
  188.      */
  189.     public function getPassword(): string
  190.     {
  191.         return $this->password;
  192.     }
  194.     public function setPassword(string $password): self
  195.     {
  196.         $this->password = $password;
  198.         return $this;
  199.     }
  201.     /**
  202.      * @see UserInterface
  203.      */
  204.     public function eraseCredentials()
  205.     {
  206.         // If you store any temporary, sensitive data on the user, clear it here
  207.         // $this->plainPassword = null;
  208.     }
  210.     public function getFirstName(): ?string
  211.     {
  212.         return $this->first_name;
  213.     }
  215.     public function setFirstName(?string $first_name): self
  216.     {
  217.         $this->first_name = $first_name;
  219.         return $this;
  220.     }
  222.     public function getLastName(): ?string
  223.     {
  224.         return $this->last_name;
  225.     }
  227.     public function setLastName(?string $last_name): self
  228.     {
  229.         $this->last_name = $last_name;
  231.         return $this;
  232.     }
  234.     public function isVerified(): bool
  235.     {
  236.         return $this->isVerified;
  237.     }
  239.     public function setIsVerified(bool $isVerified): self
  240.     {
  241.         $this->isVerified = $isVerified;
  243.         return $this;
  244.     }
  246.     public function getCompany(): ?Company
  247.     {
  248.         return $this->company;
  249.     }
  251.     public function setCompany(?Company $company): self
  252.     {
  253.         $this->company = $company;
  255.         return $this;
  256.     }
  258.     // public function __toString() {
  259.     //     return $this->id;
  260.     // }
  262.     public function getIsVerified(): ?bool
  263.     {
  264.         return $this->isVerified;
  265.     }
  267.     /**
  268.      * @return Collection<int, Order>
  269.      */
  270.     public function getOrders(): Collection
  271.     {
  272.         return $this->orders;
  273.     }
  275.     public function addOrder(Order $order): self
  276.     {
  277.         if (!$this->orders->contains($order)) {
  278.             $this->orders[] = $order;
  279.             $order->setCustomer($this);
  280.         }
  282.         return $this;
  283.     }
  285.     public function removeOrder(Order $order): self
  286.     {
  287.         if ($this->orders->removeElement($order)) {
  288.             // set the owning side to null (unless already changed)
  289.             if ($order->getCustomer() === $this) {
  290.                 $order->setCustomer(null);
  291.             }
  292.         }
  294.         return $this;
  295.     }
  297.     /**
  298.      * @return Collection<int, Subscription>
  299.      */
  300.     public function getSubscriptions(): Collection
  301.     {
  302.         return $this->subscriptions;
  303.     }
  305.     public function addSubscription(Subscription $subscription): self
  306.     {
  307.         if (!$this->subscriptions->contains($subscription)) {
  308.             $this->subscriptions[] = $subscription;
  309.             $subscription->setCreatedBy($this);
  310.         }
  312.         return $this;
  313.     }
  315.     public function removeSubscription(Subscription $subscription): self
  316.     {
  317.         if ($this->subscriptions->removeElement($subscription)) {
  318.             // set the owning side to null (unless already changed)
  319.             if ($subscription->getCreatedBy() === $this) {
  320.                 $subscription->setCreatedBy(null);
  321.             }
  322.         }
  324.         return $this;
  325.     }
  327.     /**
  328.      * @return Collection<int, Payment>
  329.      */
  330.     public function getPayments(): Collection
  331.     {
  332.         return $this->payments;
  333.     }
  335.     public function addPayment(Payment $payment): self
  336.     {
  337.         if (!$this->payments->contains($payment)) {
  338.             $this->payments[] = $payment;
  339.             $payment->setCreatedBy($this);
  340.         }
  342.         return $this;
  343.     }
  345.     public function removePayment(Payment $payment): self
  346.     {
  347.         if ($this->payments->removeElement($payment)) {
  348.             // set the owning side to null (unless already changed)
  349.             if ($payment->getCreatedBy() === $this) {
  350.                 $payment->setCreatedBy(null);
  351.             }
  352.         }
  354.         return $this;
  355.     }
  357.     /**
  358.      * @return Collection<int, Post>
  359.      */
  360.     public function getPosts(): Collection
  361.     {
  362.         return $this->posts;
  363.     }
  365.     public function addPost(Post $post): self
  366.     {
  367.         if (!$this->posts->contains($post)) {
  368.             $this->posts[] = $post;
  369.             $post->setCreatedBy($this);
  370.         }
  372.         return $this;
  373.     }
  375.     public function removePost(Post $post): self
  376.     {
  377.         if ($this->posts->removeElement($post)) {
  378.             // set the owning side to null (unless already changed)
  379.             if ($post->getCreatedBy() === $this) {
  380.                 $post->setCreatedBy(null);
  381.             }
  382.         }
  384.         return $this;
  385.     }
  387.     public function getPhoto(): ?string
  388.     {
  389.         return $this->photo;
  390.     }
  392.     public function setPhoto(?string $photo): self
  393.     {
  394.         $this->photo = $photo;
  396.         return $this;
  397.     }
  399.     public function getGoogleId(): ?string
  400.     {
  401.         return $this->google_id;
  402.     }
  404.     public function setGoogleId(?string $google_id): self
  405.     {
  406.         $this->google_id = $google_id;
  408.         return $this;
  409.     }
  411.     public function getFacebookId(): ?string
  412.     {
  413.         return $this->facebook_id;
  414.     }
  416.     public function setFacebookId(?string $facebook_id): self
  417.     {
  418.         $this->facebook_id = $facebook_id;
  420.         return $this;
  421.     }
  423.     /**
  424.      * @return Collection<int, Pointing>
  425.      */
  426.     public function getPointings(): Collection
  427.     {
  428.         return $this->pointings;
  429.     }
  431.     public function addPointing(Pointing $pointing): self
  432.     {
  433.         if (!$this->pointings->contains($pointing)) {
  434.             $this->pointings[] = $pointing;
  435.             $pointing->setCreatedBy($this);
  436.         }
  438.         return $this;
  439.     }
  441.     public function removePointing(Pointing $pointing): self
  442.     {
  443.         if ($this->pointings->removeElement($pointing)) {
  444.             // set the owning side to null (unless already changed)
  445.             if ($pointing->getCreatedBy() === $this) {
  446.                 $pointing->setCreatedBy(null);
  447.             }
  448.         }
  450.         return $this;
  451.     }
  453.     /**
  454.      * @return Collection<int, AbsenceEmployee>
  455.      */
  456.     public function getAbsenceEmployees(): Collection
  457.     {
  458.         return $this->absenceEmployees;
  459.     }
  461.     public function addAbsenceEmployee(AbsenceEmployee $absenceEmployee): self
  462.     {
  463.         if (!$this->absenceEmployees->contains($absenceEmployee)) {
  464.             $this->absenceEmployees[] = $absenceEmployee;
  465.             $absenceEmployee->setCreatedBy($this);
  466.         }
  468.         return $this;
  469.     }
  471.     public function removeAbsenceEmployee(AbsenceEmployee $absenceEmployee): self
  472.     {
  473.         if ($this->absenceEmployees->removeElement($absenceEmployee)) {
  474.             // set the owning side to null (unless already changed)
  475.             if ($absenceEmployee->getCreatedBy() === $this) {
  476.                 $absenceEmployee->setCreatedBy(null);
  477.             }
  478.         }
  480.         return $this;
  481.     }
  483.     public function isIsVerified(): ?bool
  484.     {
  485.         return $this->isVerified;
  486.     }
  488.     public function getLastLogin(): ?\DateTimeInterface
  489.     {
  490.         return $this->last_login;
  491.     }
  493.     public function setLastLogin(?\DateTimeInterface $last_login): self
  494.     {
  495.         $this->last_login = $last_login;
  497.         return $this;
  498.     }
  500.     /**
  501.      * @return Collection<int, Activity>
  502.      */
  503.     public function getActivities(): Collection
  504.     {
  505.         return $this->activities;
  506.     }
  508.     public function addActivity(Activity $activity): static
  509.     {
  510.         if (!$this->activities->contains($activity)) {
  511.             $this->activities->add($activity);
  512.             $activity->setMadeBy($this);
  513.         }
  515.         return $this;
  516.     }
  518.     public function removeActivity(Activity $activity): static
  519.     {
  520.         if ($this->activities->removeElement($activity)) {
  521.             // set the owning side to null (unless already changed)
  522.             if ($activity->getMadeBy() === $this) {
  523.                 $activity->setMadeBy(null);
  524.             }
  525.         }
  527.         return $this;
  528.     }
  530.     public function getPhone(): ?string
  531.     {
  532.         return $this->phone;
  533.     }
  535.     public function setPhone(?string $phone): static
  536.     {
  537.         $this->phone = $phone;
  539.         return $this;
  540.     }
  542.     public function isIsActive(): ?bool
  543.     {
  544.         return $this->isActive;
  545.     }
  547.     public function setIsActive(?bool $isActive): static
  548.     {
  549.         $this->isActive = $isActive;
  551.         return $this;
  552.     }
  553. }