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\Shop\Accounting\Transaction;
  7. use App\Entity\Shop\Blog\Article;
  8. use App\Entity\Shop\Blog\Comment;
  9. use App\Entity\Shop\Cart\Cart;
  10. use App\Entity\Shop\Order\Order;
  11. use App\Entity\Shop\Product\ProductReview;
  12. use App\Entity\Shop\Product\ProductReviewReply;
  13. use App\Entity\Shop\Product\ProductReviewVote;
  14. use App\Entity\Shop\Shop\Review;
  15. use App\Entity\Shop\Shop\Shop;
  16. use App\Entity\Shop\Ticket\Ticket;
  17. use App\Entity\Shop\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 ?Shop $shop = 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.     public function __construct()
  129.     {
  130.         parent::__construct();
  131.         $this->wallet = 0;
  132.         $this->orders = new ArrayCollection();
  133.         $this->carts = new ArrayCollection();
  134.         $this->reviews = new ArrayCollection();
  135.         $this->addresses = new ArrayCollection();
  136.         $this->productReviews = new ArrayCollection();
  137.         $this->productReviewVotes = new ArrayCollection();
  138.         $this->productReviewReplies = new ArrayCollection();
  139.         $this->articles = new ArrayCollection();
  140.         $this->comments = new ArrayCollection();
  141.         $this->tickets = new ArrayCollection();
  142.         $this->ticketMessages = new ArrayCollection();
  143.         $this->setVerifyCode(random_int(00000 , 99999));
  144.         $this->transactions = new ArrayCollection();
  145.     }
  147.     public function hasRole($role)
  148.     {
  149.         return in_array($role, $this->roles);
  150.     }
  152.     public function getId(): ?string
  153.     {
  154.         return $this->id;
  155.     }
  157.     public function getEmail(): ?string
  158.     {
  159.         return $this->email;
  160.     }
  162.     public function setEmail(string $email): static
  163.     {
  164.         $this->email = $email;
  166.         return $this;
  167.     }
  169.     /**
  170.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  171.      */
  172.     public function getUsername(): string
  173.     {
  174.         return (string) $this->email;
  175.     }
  177.     /**
  178.      * @see UserInterface
  179.      */
  180.     public function getRoles(): array
  181.     {
  182.         $roles = $this->roles;
  183.         // guarantee every user at least has ROLE_USER
  184.         $roles[] = 'ROLE_USER';
  186.         return array_unique($roles);
  187.     }
  189.     public function setRoles(array $roles): static
  190.     {
  191.         $this->roles = $roles;
  193.         return $this;
  194.     }
  196.     /**
  197.      * @see PasswordAuthenticatedUserInterface
  198.      */
  199.     public function getPassword(): string
  200.     {
  201.         return $this->password;
  202.     }
  204.     public function setPassword(string $password): static
  205.     {
  206.         $this->password = $password;
  208.         return $this;
  209.     }
  211.     /**
  212.      * Returning a salt is only needed, if you are not using a modern
  213.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  214.      *
  215.      * @see UserInterface
  216.      */
  217.     public function getSalt(): ?string
  218.     {
  219.         return null;
  220.     }
  222.     /**
  223.      * @see UserInterface
  224.      */
  225.     public function eraseCredentials(): void
  226.     {
  227.         // If you store any temporary, sensitive data on the user, clear it here
  228.         // $this->plainPassword = null;
  229.     }
  231.     public function getWallet(): ?string
  232.     {
  233.         return $this->wallet;
  234.     }
  236.     public function setWallet(string $wallet): static
  237.     {
  238.         $this->wallet = $wallet;
  240.         return $this;
  241.     }
  243.     public function getShop(): ?Shop
  244.     {
  245.         return $this->shop;
  246.     }
  248.     public function setShop(?Shop $shop): static
  249.     {
  250.         $this->shop = $shop;
  252.         return $this;
  253.     }
  255.     /**
  256.      * @return Collection<int, Order>
  257.      */
  258.     public function getOrders(): Collection
  259.     {
  260.         return $this->orders;
  261.     }
  263.     public function addOrder(Order $order): static
  264.     {
  265.         if (!$this->orders->contains($order)) {
  266.             $this->orders->add($order);
  267.             $order->setCustomer($this);
  268.         }
  270.         return $this;
  271.     }
  273.     public function removeOrder(Order $order): static
  274.     {
  275.         if ($this->orders->removeElement($order)) {
  276.             // set the owning side to null (unless already changed)
  277.             if ($order->getCustomer() === $this) {
  278.                 $order->setCustomer(null);
  279.             }
  280.         }
  282.         return $this;
  283.     }
  285.     /**
  286.      * @return Collection<int, Cart>
  287.      */
  288.     public function getCarts(): Collection
  289.     {
  290.         return $this->carts;
  291.     }
  293.     public function addCart(Cart $cart): static
  294.     {
  295.         if (!$this->carts->contains($cart)) {
  296.             $this->carts->add($cart);
  297.             $cart->setCustomer($this);
  298.         }
  300.         return $this;
  301.     }
  303.     public function removeCart(Cart $cart): static
  304.     {
  305.         if ($this->carts->removeElement($cart)) {
  306.             // set the owning side to null (unless already changed)
  307.             if ($cart->getCustomer() === $this) {
  308.                 $cart->setCustomer(null);
  309.             }
  310.         }
  312.         return $this;
  313.     }
  315.     /**
  316.      * @return Collection<int, Review>
  317.      */
  318.     public function getReviews(): Collection
  319.     {
  320.         return $this->reviews;
  321.     }
  323.     public function addReview(Review $review): static
  324.     {
  325.         if (!$this->reviews->contains($review)) {
  326.             $this->reviews->add($review);
  327.             $review->setCustomer($this);
  328.         }
  330.         return $this;
  331.     }
  333.     public function removeReview(Review $review): static
  334.     {
  335.         if ($this->reviews->removeElement($review)) {
  336.             // set the owning side to null (unless already changed)
  337.             if ($review->getCustomer() === $this) {
  338.                 $review->setCustomer(null);
  339.             }
  340.         }
  342.         return $this;
  343.     }
  345.     /**
  346.      * @return Collection<int, Address>
  347.      */
  348.     public function getAddresses(): Collection
  349.     {
  350.         return $this->addresses;
  351.     }
  353.     public function addAddress(Address $address): static
  354.     {
  355.         if (!$this->addresses->contains($address)) {
  356.             $this->addresses->add($address);
  357.             $address->setCustomer($this);
  358.         }
  360.         return $this;
  361.     }
  363.     public function removeAddress(Address $address): static
  364.     {
  365.         if ($this->addresses->removeElement($address)) {
  366.             // set the owning side to null (unless already changed)
  367.             if ($address->getCustomer() === $this) {
  368.                 $address->setCustomer(null);
  369.             }
  370.         }
  372.         return $this;
  373.     }
  375.     /**
  376.      * @return Collection<int, ProductReview>
  377.      */
  378.     public function getProductReviews(): Collection
  379.     {
  380.         return $this->productReviews;
  381.     }
  383.     public function addProductReview(ProductReview $productReview): static
  384.     {
  385.         if (!$this->productReviews->contains($productReview)) {
  386.             $this->productReviews->add($productReview);
  387.             $productReview->setAuthor($this);
  388.         }
  390.         return $this;
  391.     }
  393.     public function removeProductReview(ProductReview $productReview): static
  394.     {
  395.         if ($this->productReviews->removeElement($productReview)) {
  396.             // set the owning side to null (unless already changed)
  397.             if ($productReview->getAuthor() === $this) {
  398.                 $productReview->setAuthor(null);
  399.             }
  400.         }
  402.         return $this;
  403.     }
  405.     /**
  406.      * @return Collection<int, ProductReviewVote>
  407.      */
  408.     public function getProductReviewVotes(): Collection
  409.     {
  410.         return $this->productReviewVotes;
  411.     }
  413.     public function addProductReviewVote(ProductReviewVote $productReviewVote): static
  414.     {
  415.         if (!$this->productReviewVotes->contains($productReviewVote)) {
  416.             $this->productReviewVotes->add($productReviewVote);
  417.             $productReviewVote->setUser($this);
  418.         }
  420.         return $this;
  421.     }
  423.     public function removeProductReviewVote(ProductReviewVote $productReviewVote): static
  424.     {
  425.         if ($this->productReviewVotes->removeElement($productReviewVote)) {
  426.             // set the owning side to null (unless already changed)
  427.             if ($productReviewVote->getUser() === $this) {
  428.                 $productReviewVote->setUser(null);
  429.             }
  430.         }
  432.         return $this;
  433.     }
  435.     /**
  436.      * @return Collection<int, ProductReviewReply>
  437.      */
  438.     public function getProductReviewReplies(): Collection
  439.     {
  440.         return $this->productReviewReplies;
  441.     }
  443.     public function addProductReviewReply(ProductReviewReply $productReviewReply): static
  444.     {
  445.         if (!$this->productReviewReplies->contains($productReviewReply)) {
  446.             $this->productReviewReplies->add($productReviewReply);
  447.             $productReviewReply->setAuthor($this);
  448.         }
  450.         return $this;
  451.     }
  453.     public function removeProductReviewReply(ProductReviewReply $productReviewReply): static
  454.     {
  455.         if ($this->productReviewReplies->removeElement($productReviewReply)) {
  456.             // set the owning side to null (unless already changed)
  457.             if ($productReviewReply->getAuthor() === $this) {
  458.                 $productReviewReply->setAuthor(null);
  459.             }
  460.         }
  462.         return $this;
  463.     }
  465.     /**
  466.      * @return Collection<int, Article>
  467.      */
  468.     public function getArticles(): Collection
  469.     {
  470.         return $this->articles;
  471.     }
  473.     public function addArticle(Article $article): static
  474.     {
  475.         if (!$this->articles->contains($article)) {
  476.             $this->articles->add($article);
  477.             $article->setAuthor($this);
  478.         }
  480.         return $this;
  481.     }
  483.     public function removeArticle(Article $article): static
  484.     {
  485.         if ($this->articles->removeElement($article)) {
  486.             // set the owning side to null (unless already changed)
  487.             if ($article->getAuthor() === $this) {
  488.                 $article->setAuthor(null);
  489.             }
  490.         }
  492.         return $this;
  493.     }
  495.     /**
  496.      * @return Collection<int, Comment>
  497.      */
  498.     public function getComments(): Collection
  499.     {
  500.         return $this->comments;
  501.     }
  503.     public function addComment(Comment $comment): static
  504.     {
  505.         if (!$this->comments->contains($comment)) {
  506.             $this->comments->add($comment);
  507.             $comment->setAuthor($this);
  508.         }
  510.         return $this;
  511.     }
  513.     public function removeComment(Comment $comment): static
  514.     {
  515.         if ($this->comments->removeElement($comment)) {
  516.             // set the owning side to null (unless already changed)
  517.             if ($comment->getAuthor() === $this) {
  518.                 $comment->setAuthor(null);
  519.             }
  520.         }
  522.         return $this;
  523.     }
  525.     /**
  526.      * @return Collection<int, Ticket>
  527.      */
  528.     public function getTickets(): Collection
  529.     {
  530.         return $this->tickets;
  531.     }
  533.     public function addTicket(Ticket $ticket): static
  534.     {
  535.         if (!$this->tickets->contains($ticket)) {
  536.             $this->tickets->add($ticket);
  537.             $ticket->setCreator($this);
  538.         }
  540.         return $this;
  541.     }
  543.     public function removeTicket(Ticket $ticket): static
  544.     {
  545.         if ($this->tickets->removeElement($ticket)) {
  546.             // set the owning side to null (unless already changed)
  547.             if ($ticket->getCreator() === $this) {
  548.                 $ticket->setCreator(null);
  549.             }
  550.         }
  552.         return $this;
  553.     }
  555.     /**
  556.      * @return Collection<int, TicketMessage>
  557.      */
  558.     public function getTicketMessages(): Collection
  559.     {
  560.         return $this->ticketMessages;
  561.     }
  563.     public function addTicketMessage(TicketMessage $ticketMessage): static
  564.     {
  565.         if (!$this->ticketMessages->contains($ticketMessage)) {
  566.             $this->ticketMessages->add($ticketMessage);
  567.             $ticketMessage->setAuthor($this);
  568.         }
  570.         return $this;
  571.     }
  573.     public function removeTicketMessage(TicketMessage $ticketMessage): static
  574.     {
  575.         if ($this->ticketMessages->removeElement($ticketMessage)) {
  576.             // set the owning side to null (unless already changed)
  577.             if ($ticketMessage->getAuthor() === $this) {
  578.                 $ticketMessage->setAuthor(null);
  579.             }
  580.         }
  582.         return $this;
  583.     }
  585.     public function getMobile(): ?string
  586.     {
  587.         return $this->mobile;
  588.     }
  590.     public function setMobile(?string $mobile): void
  591.     {
  592.         $this->mobile = $mobile;
  593.     }
  595.     public function getIdentifier(): string
  596.     {
  597.         return $this->identifier;
  598.     }
  600.     public function setIdentifier(string $identifier): void
  601.     {
  602.         $this->identifier = $identifier;
  603.     }
  605.     public function isVerified(): bool
  606.     {
  607.         return $this->isVerified;
  608.     }
  610.     public function setIsVerified(bool $isVerified): void
  611.     {
  612.         $this->isVerified = $isVerified;
  613.     }
  615.     public function getVerifyCode(): ?int
  616.     {
  617.         return $this->verifyCode;
  618.     }
  620.     public function setVerifyCode(?int $verifyCode): void
  621.     {
  622.         $this->verifyCode = $verifyCode;
  623.     }
  627.     public function getLastName(): ?string
  628.     {
  629.         return $this->lastName;
  630.     }
  632.     public function setLastName(?string $lastName): static
  633.     {
  634.         $this->lastName = $lastName;
  636.         return $this;
  637.     }
  639.     /**
  640.      * @return Collection<int, Transaction>
  641.      */
  642.     public function getTransactions(): Collection
  643.     {
  644.         return $this->transactions;
  645.     }
  647.     public function addTransaction(Transaction $transaction): static
  648.     {
  649.         if (!$this->transactions->contains($transaction)) {
  650.             $this->transactions->add($transaction);
  651.             $transaction->setOwner($this);
  652.         }
  654.         return $this;
  655.     }
  657.     public function removeTransaction(Transaction $transaction): static
  658.     {
  659.         if ($this->transactions->removeElement($transaction)) {
  660.             // set the owning side to null (unless already changed)
  661.             if ($transaction->getOwner() === $this) {
  662.                 $transaction->setOwner(null);
  663.             }
  664.         }
  666.         return $this;
  667.     }
  669.     public function getFirstName(): mixed
  670.     {
  671.         return $this->firstName;
  672.     }
  674.     public function setFirstName(mixed $firstName): void
  675.     {
  676.         $this->firstName = $firstName;
  677.     }
  678. }