src/Entity/Generic/Customer/Customer.php line 34

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Generic\Customer;
  5. use App\Entity\BaseEntity;
  6. use App\Entity\Website\Accounting\Transaction;
  7. use App\Entity\Website\Blog\Article;
  8. use App\Entity\Website\Blog\Comment;
  9. use App\Entity\Website\Cart\Cart;
  10. use App\Entity\Website\Order\Order;
  11. use App\Entity\Website\Product\ProductReview;
  12. use App\Entity\Website\Product\ProductReviewReply;
  13. use App\Entity\Website\Product\ProductReviewVote;
  14. use App\Entity\Website\Website\Review;
  15. use App\Entity\Website\Website\Website;
  16. use App\Entity\Website\Ticket\Ticket;
  17. use App\Entity\Website\Ticket\TicketMessage;
  18. use App\Repository\Generic\CustomerRepository;
  19. use Doctrine\Common\Collections\ArrayCollection;
  20. use Doctrine\Common\Collections\Collection;
  21. use Doctrine\DBAL\Types\Types;
  22. use Doctrine\ORM\Mapping as ORM;
  23. use Symfony\Bridge\Doctrine\IdGenerator\UuidGenerator;
  24. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  25. use Symfony\Component\Security\Core\User\UserInterface;
  27. #[ORM\Table(
  28.     name: 'customer',
  29.     uniqueConstraints: [
  30.         new ORM\UniqueConstraint(name: 'shop_identifier_unique', columns: ['shop_id', 'identifier' , 'mobile'])
  31.     ]
  32. )]
  33. #[ORM\Entity(repositoryClass: CustomerRepository::class)]
  34. class Customer extends BaseEntity implements UserInterface, PasswordAuthenticatedUserInterface
  35. {
  36.     #[ORM\Id]
  37.     #[ORM\Column(type: 'guid', unique: true)]
  38.     #[ORM\GeneratedValue(strategy: 'CUSTOM')]
  39.     #[ORM\CustomIdGenerator(class: UuidGenerator::class)]
  40.     private ?string $id;
  42.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  43.     private mixed $firstName;
  45.     #[ORM\Column(length: 180 , nullable: true)]
  46.     private ?string $email = null;
  48.     #[ORM\Column]
  49.     private array $roles = [];
  51.     #[ORM\Column(length: 20, nullable: true)]
  52.     private ?string $mobile = null;
  54.     #[ORM\Column(length: 180)]
  55.     private string $identifier; // ایمیل یا شماره موبایل (برای ورود)
  57.     /**
  58.      * @var string The hashed password
  59.      */
  60.     #[ORM\Column]
  61.     private ?string $password = null;
  63.     #[ORM\Column(type: 'boolean')]
  64.     private bool $isVerified = false;
  66.     #[ORM\Column(type: Types::BIGINT)]
  67.     private ?string $wallet = null;
  69.     #[ORM\ManyToOne(inversedBy: 'customers')]
  70.     #[ORM\JoinColumn(nullable: false)]
  71.     private ?Website $website = null;
  73.     public function getUserIdentifier(): string
  74.     {
  75.         return $this->identifier;
  76.     }
  79.     public function __toString()
  80.     {
  81.         return $this->getIdentifier();
  82.     }
  84.     #[ORM\OneToMany(mappedBy: 'customer', targetEntity: Order::class)]
  85.     private Collection $orders;
  87.     #[ORM\OneToMany(mappedBy: 'customer', targetEntity: Cart::class)]
  88.     private Collection $carts;
  90.     #[ORM\OneToMany(mappedBy: 'customer', targetEntity: Review::class)]
  91.     private Collection $reviews;
  93.     #[ORM\OneToMany(mappedBy: 'customer', targetEntity: Address::class)]
  94.     private Collection $addresses;
  96.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ProductReview::class)]
  97.     private Collection $productReviews;
  99.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ProductReviewVote::class)]
  100.     private Collection $productReviewVotes;
  102.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: ProductReviewReply::class)]
  103.     private Collection $productReviewReplies;
  105.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Article::class)]
  106.     private Collection $articles;
  108.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Comment::class)]
  109.     private Collection $comments;
  111.     #[ORM\OneToMany(mappedBy: 'creator', targetEntity: Ticket::class)]
  112.     private Collection $tickets;
  114.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: TicketMessage::class)]
  115.     private Collection $ticketMessages;
  117.     #[ORM\Column(nullable: true)]
  118.     private ?int $verifyCode = null;
  122.     #[ORM\Column(length: 255, nullable: true)]
  123.     private ?string $lastName = null;
  125.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Transaction::class)]
  126.     private Collection $transactions;
  128.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  129.     private ?\DateTimeInterface $passwordResetAt = null;
  131.     public function __construct()
  132.     {
  133.         parent::__construct();
  134.         $this->wallet = 0;
  135.         $this->orders = new ArrayCollection();
  136.         $this->carts = new ArrayCollection();
  137.         $this->reviews = new ArrayCollection();
  138.         $this->addresses = new ArrayCollection();
  139.         $this->productReviews = new ArrayCollection();
  140.         $this->productReviewVotes = new ArrayCollection();
  141.         $this->productReviewReplies = new ArrayCollection();
  142.         $this->articles = new ArrayCollection();
  143.         $this->comments = new ArrayCollection();
  144.         $this->tickets = new ArrayCollection();
  145.         $this->ticketMessages = new ArrayCollection();
  146.         $this->setVerifyCode(random_int(00000 , 99999));
  147.         $this->transactions = new ArrayCollection();
  148.     }
  150.     public function hasRole($role)
  151.     {
  152.         return in_array($role, $this->roles);
  153.     }
  155.     public function getId(): ?string
  156.     {
  157.         return $this->id;
  158.     }
  160.     public function getEmail(): ?string
  161.     {
  162.         return $this->email;
  163.     }
  165.     public function setEmail(string $email): static
  166.     {
  167.         $this->email = $email;
  169.         return $this;
  170.     }
  172.     /**
  173.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  174.      */
  175.     public function getUsername(): string
  176.     {
  177.         return (string) $this->email;
  178.     }
  180.     /**
  181.      * @see UserInterface
  182.      */
  183.     public function getRoles(): array
  184.     {
  185.         $roles = $this->roles;
  186.         // guarantee every user at least has ROLE_USER
  187.         $roles[] = 'ROLE_USER';
  189.         return array_unique($roles);
  190.     }
  192.     public function setRoles(array $roles): static
  193.     {
  194.         $this->roles = $roles;
  196.         return $this;
  197.     }
  199.     /**
  200.      * @see PasswordAuthenticatedUserInterface
  201.      */
  202.     public function getPassword(): string
  203.     {
  204.         return $this->password;
  205.     }
  207.     public function setPassword(string $password): static
  208.     {
  209.         $this->password = $password;
  211.         return $this;
  212.     }
  214.     /**
  215.      * Returning a salt is only needed, if you are not using a modern
  216.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  217.      *
  218.      * @see UserInterface
  219.      */
  220.     public function getSalt(): ?string
  221.     {
  222.         return null;
  223.     }
  225.     /**
  226.      * @see UserInterface
  227.      */
  228.     public function eraseCredentials(): void
  229.     {
  230.         // If you store any temporary, sensitive data on the user, clear it here
  231.         // $this->plainPassword = null;
  232.     }
  234.     public function getWallet(): ?string
  235.     {
  236.         return $this->wallet;
  237.     }
  239.     public function setWallet(string $wallet): static
  240.     {
  241.         $this->wallet = $wallet;
  243.         return $this;
  244.     }
  246.     public function getWebsite(): ?Website
  247.     {
  248.         return $this->website;
  249.     }
  251.     public function setWebsite(?Website $shop): static
  252.     {
  253.         $this->website = $shop;
  255.         return $this;
  256.     }
  258.     /**
  259.      * @return Collection<int, Order>
  260.      */
  261.     public function getOrders(): Collection
  262.     {
  263.         return $this->orders;
  264.     }
  266.     public function addOrder(Order $order): static
  267.     {
  268.         if (!$this->orders->contains($order)) {
  269.             $this->orders->add($order);
  270.             $order->setCustomer($this);
  271.         }
  273.         return $this;
  274.     }
  276.     public function removeOrder(Order $order): static
  277.     {
  278.         if ($this->orders->removeElement($order)) {
  279.             // set the owning side to null (unless already changed)
  280.             if ($order->getCustomer() === $this) {
  281.                 $order->setCustomer(null);
  282.             }
  283.         }
  285.         return $this;
  286.     }
  288.     /**
  289.      * @return Collection<int, Cart>
  290.      */
  291.     public function getCarts(): Collection
  292.     {
  293.         return $this->carts;
  294.     }
  296.     public function addCart(Cart $cart): static
  297.     {
  298.         if (!$this->carts->contains($cart)) {
  299.             $this->carts->add($cart);
  300.             $cart->setCustomer($this);
  301.         }
  303.         return $this;
  304.     }
  306.     public function removeCart(Cart $cart): static
  307.     {
  308.         if ($this->carts->removeElement($cart)) {
  309.             // set the owning side to null (unless already changed)
  310.             if ($cart->getCustomer() === $this) {
  311.                 $cart->setCustomer(null);
  312.             }
  313.         }
  315.         return $this;
  316.     }
  318.     /**
  319.      * @return Collection<int, Review>
  320.      */
  321.     public function getReviews(): Collection
  322.     {
  323.         return $this->reviews;
  324.     }
  326.     public function addReview(Review $review): static
  327.     {
  328.         if (!$this->reviews->contains($review)) {
  329.             $this->reviews->add($review);
  330.             $review->setCustomer($this);
  331.         }
  333.         return $this;
  334.     }
  336.     public function removeReview(Review $review): static
  337.     {
  338.         if ($this->reviews->removeElement($review)) {
  339.             // set the owning side to null (unless already changed)
  340.             if ($review->getCustomer() === $this) {
  341.                 $review->setCustomer(null);
  342.             }
  343.         }
  345.         return $this;
  346.     }
  348.     /**
  349.      * @return Collection<int, Address>
  350.      */
  351.     public function getAddresses(): Collection
  352.     {
  353.         return $this->addresses;
  354.     }
  356.     public function addAddress(Address $address): static
  357.     {
  358.         if (!$this->addresses->contains($address)) {
  359.             $this->addresses->add($address);
  360.             $address->setCustomer($this);
  361.         }
  363.         return $this;
  364.     }
  366.     public function removeAddress(Address $address): static
  367.     {
  368.         if ($this->addresses->removeElement($address)) {
  369.             // set the owning side to null (unless already changed)
  370.             if ($address->getCustomer() === $this) {
  371.                 $address->setCustomer(null);
  372.             }
  373.         }
  375.         return $this;
  376.     }
  378.     /**
  379.      * @return Collection<int, ProductReview>
  380.      */
  381.     public function getProductReviews(): Collection
  382.     {
  383.         return $this->productReviews;
  384.     }
  386.     public function addProductReview(ProductReview $productReview): static
  387.     {
  388.         if (!$this->productReviews->contains($productReview)) {
  389.             $this->productReviews->add($productReview);
  390.             $productReview->setAuthor($this);
  391.         }
  393.         return $this;
  394.     }
  396.     public function removeProductReview(ProductReview $productReview): static
  397.     {
  398.         if ($this->productReviews->removeElement($productReview)) {
  399.             // set the owning side to null (unless already changed)
  400.             if ($productReview->getAuthor() === $this) {
  401.                 $productReview->setAuthor(null);
  402.             }
  403.         }
  405.         return $this;
  406.     }
  408.     /**
  409.      * @return Collection<int, ProductReviewVote>
  410.      */
  411.     public function getProductReviewVotes(): Collection
  412.     {
  413.         return $this->productReviewVotes;
  414.     }
  416.     public function addProductReviewVote(ProductReviewVote $productReviewVote): static
  417.     {
  418.         if (!$this->productReviewVotes->contains($productReviewVote)) {
  419.             $this->productReviewVotes->add($productReviewVote);
  420.             $productReviewVote->setUser($this);
  421.         }
  423.         return $this;
  424.     }
  426.     public function removeProductReviewVote(ProductReviewVote $productReviewVote): static
  427.     {
  428.         if ($this->productReviewVotes->removeElement($productReviewVote)) {
  429.             // set the owning side to null (unless already changed)
  430.             if ($productReviewVote->getUser() === $this) {
  431.                 $productReviewVote->setUser(null);
  432.             }
  433.         }
  435.         return $this;
  436.     }
  438.     /**
  439.      * @return Collection<int, ProductReviewReply>
  440.      */
  441.     public function getProductReviewReplies(): Collection
  442.     {
  443.         return $this->productReviewReplies;
  444.     }
  446.     public function addProductReviewReply(ProductReviewReply $productReviewReply): static
  447.     {
  448.         if (!$this->productReviewReplies->contains($productReviewReply)) {
  449.             $this->productReviewReplies->add($productReviewReply);
  450.             $productReviewReply->setAuthor($this);
  451.         }
  453.         return $this;
  454.     }
  456.     public function removeProductReviewReply(ProductReviewReply $productReviewReply): static
  457.     {
  458.         if ($this->productReviewReplies->removeElement($productReviewReply)) {
  459.             // set the owning side to null (unless already changed)
  460.             if ($productReviewReply->getAuthor() === $this) {
  461.                 $productReviewReply->setAuthor(null);
  462.             }
  463.         }
  465.         return $this;
  466.     }
  468.     /**
  469.      * @return Collection<int, Article>
  470.      */
  471.     public function getArticles(): Collection
  472.     {
  473.         return $this->articles;
  474.     }
  476.     public function addArticle(Article $article): static
  477.     {
  478.         if (!$this->articles->contains($article)) {
  479.             $this->articles->add($article);
  480.             $article->setAuthor($this);
  481.         }
  483.         return $this;
  484.     }
  486.     public function removeArticle(Article $article): static
  487.     {
  488.         if ($this->articles->removeElement($article)) {
  489.             // set the owning side to null (unless already changed)
  490.             if ($article->getAuthor() === $this) {
  491.                 $article->setAuthor(null);
  492.             }
  493.         }
  495.         return $this;
  496.     }
  498.     /**
  499.      * @return Collection<int, Comment>
  500.      */
  501.     public function getComments(): Collection
  502.     {
  503.         return $this->comments;
  504.     }
  506.     public function addComment(Comment $comment): static
  507.     {
  508.         if (!$this->comments->contains($comment)) {
  509.             $this->comments->add($comment);
  510.             $comment->setAuthor($this);
  511.         }
  513.         return $this;
  514.     }
  516.     public function removeComment(Comment $comment): static
  517.     {
  518.         if ($this->comments->removeElement($comment)) {
  519.             // set the owning side to null (unless already changed)
  520.             if ($comment->getAuthor() === $this) {
  521.                 $comment->setAuthor(null);
  522.             }
  523.         }
  525.         return $this;
  526.     }
  528.     /**
  529.      * @return Collection<int, Ticket>
  530.      */
  531.     public function getTickets(): Collection
  532.     {
  533.         return $this->tickets;
  534.     }
  536.     public function addTicket(Ticket $ticket): static
  537.     {
  538.         if (!$this->tickets->contains($ticket)) {
  539.             $this->tickets->add($ticket);
  540.             $ticket->setCreator($this);
  541.         }
  543.         return $this;
  544.     }
  546.     public function removeTicket(Ticket $ticket): static
  547.     {
  548.         if ($this->tickets->removeElement($ticket)) {
  549.             // set the owning side to null (unless already changed)
  550.             if ($ticket->getCreator() === $this) {
  551.                 $ticket->setCreator(null);
  552.             }
  553.         }
  555.         return $this;
  556.     }
  558.     /**
  559.      * @return Collection<int, TicketMessage>
  560.      */
  561.     public function getTicketMessages(): Collection
  562.     {
  563.         return $this->ticketMessages;
  564.     }
  566.     public function addTicketMessage(TicketMessage $ticketMessage): static
  567.     {
  568.         if (!$this->ticketMessages->contains($ticketMessage)) {
  569.             $this->ticketMessages->add($ticketMessage);
  570.             $ticketMessage->setAuthor($this);
  571.         }
  573.         return $this;
  574.     }
  576.     public function removeTicketMessage(TicketMessage $ticketMessage): static
  577.     {
  578.         if ($this->ticketMessages->removeElement($ticketMessage)) {
  579.             // set the owning side to null (unless already changed)
  580.             if ($ticketMessage->getAuthor() === $this) {
  581.                 $ticketMessage->setAuthor(null);
  582.             }
  583.         }
  585.         return $this;
  586.     }
  588.     public function getMobile(): ?string
  589.     {
  590.         return $this->mobile;
  591.     }
  593.     public function setMobile(?string $mobile): void
  594.     {
  595.         $this->mobile = $mobile;
  596.     }
  598.     public function getIdentifier(): string
  599.     {
  600.         return $this->identifier;
  601.     }
  603.     public function setIdentifier(string $identifier): void
  604.     {
  605.         $this->identifier = $identifier;
  606.     }
  608.     public function isVerified(): bool
  609.     {
  610.         return $this->isVerified;
  611.     }
  613.     public function setIsVerified(bool $isVerified): void
  614.     {
  615.         $this->isVerified = $isVerified;
  616.     }
  618.     public function getVerifyCode(): ?int
  619.     {
  620.         return $this->verifyCode;
  621.     }
  623.     public function setVerifyCode(?int $verifyCode): void
  624.     {
  625.         $this->verifyCode = $verifyCode;
  626.     }
  630.     public function getLastName(): ?string
  631.     {
  632.         return $this->lastName;
  633.     }
  635.     public function setLastName(?string $lastName): static
  636.     {
  637.         $this->lastName = $lastName;
  639.         return $this;
  640.     }
  642.     /**
  643.      * @return Collection<int, Transaction>
  644.      */
  645.     public function getTransactions(): Collection
  646.     {
  647.         return $this->transactions;
  648.     }
  650.     public function addTransaction(Transaction $transaction): static
  651.     {
  652.         if (!$this->transactions->contains($transaction)) {
  653.             $this->transactions->add($transaction);
  654.             $transaction->setOwner($this);
  655.         }
  657.         return $this;
  658.     }
  660.     public function removeTransaction(Transaction $transaction): static
  661.     {
  662.         if ($this->transactions->removeElement($transaction)) {
  663.             // set the owning side to null (unless already changed)
  664.             if ($transaction->getOwner() === $this) {
  665.                 $transaction->setOwner(null);
  666.             }
  667.         }
  669.         return $this;
  670.     }
  672.     public function getFirstName(): mixed
  673.     {
  674.         return $this->firstName;
  675.     }
  677.     public function setFirstName(mixed $firstName): void
  678.     {
  679.         $this->firstName = $firstName;
  680.     }
  682.     public function getPasswordResetAt(): ?\DateTimeInterface
  683.     {
  684.         return $this->passwordResetAt;
  685.     }
  687.     public function setPasswordResetAt(?\DateTimeInterface $passwordResetAt): static
  688.     {
  689.         $this->passwordResetAt = $passwordResetAt;
  691.         return $this;
  692.     }
  693. }