src/IlaveU/ShopBundle/Entity/Store/Store.php line 26

  1. <?php
  3. namespace App\IlaveU\ShopBundle\Entity\Store;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use App\Entity\User;
  7. use App\IlaveU\ShopBundle\Entity\Customer\Customer;
  8. use App\IlaveU\ShopBundle\Entity\Order\Order;
  9. use App\IlaveU\ShopBundle\Entity\Product\Product;
  10. use App\IlaveU\ShopBundle\Entity\Resource\Agent;
  11. use App\IlaveU\ShopBundle\Entity\Shipping\City;
  12. use App\IlaveU\ShopBundle\Entity\Shipping\CityRegion;
  13. use App\IlaveU\ShopBundle\Entity\Shipping\Shipment;
  14. use App\IlaveU\ShopBundle\Entity\Shipping\CashBox;
  15. use App\Repository\IlaveU\ShopBundle\Entity\Store\StoreRepository;
  16. use Doctrine\Common\Collections\ArrayCollection;
  17. use Doctrine\Common\Collections\Collection;
  18. use Doctrine\DBAL\Types\Types;
  19. use Doctrine\ORM\Mapping as ORM;
  20. use Symfony\Component\Validator\Constraints as Assert;
  21. use Gedmo\Mapping\Annotation as Gedmo;
  23. #[ORM\Entity(repositoryClass: StoreRepository::class)]
  24. #[ApiResource]
  25. #[Gedmo\SoftDeleteable(fieldName: 'deletedAt', timeAware: false, hardDelete: true)]
  26. class Store
  27. {
  28.     #[ORM\Id]
  29.     #[ORM\GeneratedValue]
  30.     #[ORM\Column]
  31.     private ?int $id = null;
  33.     #[ORM\Column(length: 255)]
  34.     private ?string $name = null;
  36.     #[ORM\Column(length: 255)]
  37.     #[Gedmo\Slug(fields: ['name'])]
  38.     private ?string $code = null;
  40.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  41.     private ?\DateTimeInterface $createdAt = null;
  43.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  44.     private ?string $description = null;
  46.     #[ORM\ManyToOne(inversedBy: 'stores')]
  47.     #[ORM\JoinColumn(nullable: false)]
  48.     private ?City $city = null;
  50.     #[ORM\OneToOne(cascade: ['persist', 'remove'])]
  51.     #[ORM\JoinColumn(nullable: false)]
  52.     #[Assert\Valid]
  53.     private ?User $user = null;
  55.     #[ORM\ManyToOne(inversedBy: 'stores')]
  56.     #[ORM\JoinColumn(nullable: true)]
  57.     private ?CityRegion $cityRegion = null;
  59.     #[ORM\Column(length: 255, nullable: true)]
  60.     private ?string $storeType = null;
  62.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: CashBox::class)]
  63.     private Collection $cashBoxes;
  65.     #[ORM\OneToMany(mappedBy: 'collectedByStore', targetEntity: Shipment::class)]
  66.     private Collection $collectedShipments;
  68.     #[ORM\OneToMany(mappedBy: 'shippedByStore', targetEntity: Shipment::class)]
  69.     private Collection $shippedShipments;
  71.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Product::class)]
  72.     private Collection $products;
  74.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Order::class)]
  75.     private Collection $orders;
  77.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Agent::class)]
  78.     private Collection $agents;
  80.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Customer::class)]
  81.     private Collection $customers;
  84.     #[ORM\Column(nullable: true)]
  85.     private ?\DateTimeImmutable $deletedAt = null;
  87.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: User::class)]
  88.     private Collection $users;
  92.     public function __toString()
  93.     {
  94.         return (string)$this->name;
  95.     }
  97.     public function __construct()
  98.     {
  99.         $this->user = new User();
  100.         $this->cashBoxes = new ArrayCollection();
  101.         $this->collectedShipments = new ArrayCollection();
  102.         $this->shippedShipments = new ArrayCollection();
  103.         $this->products = new ArrayCollection();
  104.         $this->orders = new ArrayCollection();
  105.         $this->agents = new ArrayCollection();
  106.         $this->customers = new ArrayCollection();
  107.         $this->users = new ArrayCollection();
  108.     }
  110.     public function getId(): ?int
  111.     {
  112.         return $this->id;
  113.     }
  115.     public function getName(): ?string
  116.     {
  117.         return $this->name;
  118.     }
  120.     public function setName(string $name): self
  121.     {
  122.         $this->name = $name;
  124.         return $this;
  125.     }
  127.     public function getCode(): ?string
  128.     {
  129.         return $this->code;
  130.     }
  132.     public function setCode(?string $code): self
  133.     {
  134.         $this->code = $code;
  136.         return $this;
  137.     }
  139.     public function getCreatedAt(): ?\DateTimeInterface
  140.     {
  141.         return $this->createdAt;
  142.     }
  144.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  145.     {
  146.         $this->createdAt = $createdAt;
  148.         return $this;
  149.     }
  151.     public function getDescription(): ?string
  152.     {
  153.         return $this->description;
  154.     }
  156.     public function setDescription(?string $description): self
  157.     {
  158.         $this->description = $description;
  160.         return $this;
  161.     }
  163.     public function getCity(): ?City
  164.     {
  165.         return $this->city;
  166.     }
  168.     public function setCity(?City $city): self
  169.     {
  170.         $this->city = $city;
  172.         return $this;
  173.     }
  175.     public function getUser(): ?User
  176.     {
  177.         return $this->user;
  178.     }
  180.     public function setUser(User $user): self
  181.     {
  182.         $this->user = $user;
  184.         return $this;
  185.     }
  187.     public function getCityRegion(): ?CityRegion
  188.     {
  189.         return $this->cityRegion;
  190.     }
  192.     public function setCityRegion(?CityRegion $cityRegion): self
  193.     {
  194.         $this->cityRegion = $cityRegion;
  196.         return $this;
  197.     }
  199.     public function getStoreType(): ?string
  200.     {
  201.         return $this->storeType;
  202.     }
  204.     public function setStoreType(?string $storeType): self
  205.     {
  206.         $this->storeType = $storeType;
  208.         return $this;
  209.     }
  211.     /**
  212.      * @return Collection<int, CashBox>
  213.      */
  214.     public function getCashBoxes(): Collection
  215.     {
  216.         return $this->cashBoxes;
  217.     }
  219.     public function addCashBox(CashBox $cashBox): self
  220.     {
  221.         if (!$this->cashBoxes->contains($cashBox)) {
  222.             $this->cashBoxes->add($cashBox);
  223.             $cashBox->setStore($this);
  224.         }
  226.         return $this;
  227.     }
  229.     public function removeCashBox(CashBox $cashBox): self
  230.     {
  231.         if ($this->cashBoxes->removeElement($cashBox)) {
  232.             // set the owning side to null (unless already changed)
  233.             if ($cashBox->getStore() === $this) {
  234.                 $cashBox->setStore(null);
  235.             }
  236.         }
  238.         return $this;
  239.     }
  241.     /**
  242.      * @return Collection<int, Shipment>
  243.      */
  244.     public function getCollectedShipments(): Collection
  245.     {
  246.         return $this->collectedShipments;
  247.     }
  249.     public function addCollectedShipment(Shipment $collectedShipment): self
  250.     {
  251.         if (!$this->collectedShipments->contains($collectedShipment)) {
  252.             $this->collectedShipments->add($collectedShipment);
  253.             $collectedShipment->setCollectedByStore($this);
  254.         }
  256.         return $this;
  257.     }
  259.     public function removeCollectedShipment(Shipment $collectedShipment): self
  260.     {
  261.         if ($this->collectedShipments->removeElement($collectedShipment)) {
  262.             // set the owning side to null (unless already changed)
  263.             if ($collectedShipment->getCollectedByStore() === $this) {
  264.                 $collectedShipment->setCollectedByStore(null);
  265.             }
  266.         }
  268.         return $this;
  269.     }
  271.     /**
  272.      * @return Collection<int, Shipment>
  273.      */
  274.     public function getShippedShipments(): Collection
  275.     {
  276.         return $this->shippedShipments;
  277.     }
  279.     public function addShippedShipment(Shipment $shippedShipment): self
  280.     {
  281.         if (!$this->shippedShipments->contains($shippedShipment)) {
  282.             $this->shippedShipments->add($shippedShipment);
  283.             $shippedShipment->setShippedByStore($this);
  284.         }
  286.         return $this;
  287.     }
  289.     public function removeShippedShipment(Shipment $shippedShipment): self
  290.     {
  291.         if ($this->shippedShipments->removeElement($shippedShipment)) {
  292.             // set the owning side to null (unless already changed)
  293.             if ($shippedShipment->getShippedByStore() === $this) {
  294.                 $shippedShipment->setShippedByStore(null);
  295.             }
  296.         }
  298.         return $this;
  299.     }
  301.     /**
  302.      * @return Collection<int, Product>
  303.      */
  304.     public function getProducts(): Collection
  305.     {
  306.         return $this->products;
  307.     }
  309.     public function addProduct(Product $product): self
  310.     {
  311.         if (!$this->products->contains($product)) {
  312.             $this->products->add($product);
  313.             $product->setStore($this);
  314.         }
  316.         return $this;
  317.     }
  319.     public function removeProduct(Product $product): self
  320.     {
  321.         if ($this->products->removeElement($product)) {
  322.             // set the owning side to null (unless already changed)
  323.             if ($product->getStore() === $this) {
  324.                 $product->setStore(null);
  325.             }
  326.         }
  328.         return $this;
  329.     }
  331.     /**
  332.      * @return Collection<int, Order>
  333.      */
  334.     public function getOrders(): Collection
  335.     {
  336.         return $this->orders;
  337.     }
  339.     public function addOrder(Order $order): self
  340.     {
  341.         if (!$this->orders->contains($order)) {
  342.             $this->orders->add($order);
  343.             $order->setStore($this);
  344.         }
  346.         return $this;
  347.     }
  349.     public function removeOrder(Order $order): self
  350.     {
  351.         if ($this->orders->removeElement($order)) {
  352.             // set the owning side to null (unless already changed)
  353.             if ($order->getStore() === $this) {
  354.                 $order->setStore(null);
  355.             }
  356.         }
  358.         return $this;
  359.     }
  361.     /**
  362.      * @return Collection<int, Agent>
  363.      */
  364.     public function getAgents(): Collection
  365.     {
  366.         return $this->agents;
  367.     }
  369.     public function addAgent(Agent $agent): self
  370.     {
  371.         if (!$this->agents->contains($agent)) {
  372.             $this->agents->add($agent);
  373.             $agent->setStore($this);
  374.         }
  376.         return $this;
  377.     }
  379.     public function removeAgent(Agent $agent): self
  380.     {
  381.         if ($this->agents->removeElement($agent)) {
  382.             // set the owning side to null (unless already changed)
  383.             if ($agent->getStore() === $this) {
  384.                 $agent->setStore(null);
  385.             }
  386.         }
  388.         return $this;
  389.     }
  391.     /**
  392.      * @return Collection<int, Customer>
  393.      */
  394.     public function getCustomers(): Collection
  395.     {
  396.         return $this->customers;
  397.     }
  399.     public function addCustomer(Customer $customer): self
  400.     {
  401.         if (!$this->customers->contains($customer)) {
  402.             $this->customers->add($customer);
  403.             $customer->setStore($this);
  404.         }
  406.         return $this;
  407.     }
  409.     public function removeCustomer(Customer $customer): self
  410.     {
  411.         if ($this->customers->removeElement($customer)) {
  412.             // set the owning side to null (unless already changed)
  413.             if ($customer->getStore() === $this) {
  414.                 $customer->setStore(null);
  415.             }
  416.         }
  418.         return $this;
  419.     }
  421.         /**
  422.      * Get the value of deletedAt
  423.      */ 
  424.     public function getDeletedAt()
  425.     {
  426.         return $this->deletedAt;
  427.     }
  429.     /**
  430.      * Set the value of deletedAt
  431.      *
  432.      * @return  self
  433.      */ 
  434.     public function setDeletedAt($deletedAt)
  435.     {
  436.         $this->deletedAt = $deletedAt;
  438.         return $this;
  439.     }
  441.     /**
  442.      * @return Collection<int, User>
  443.      */
  444.     public function getUsers(): Collection
  445.     {
  446.         return $this->users;
  447.     }
  449.     public function addUser(User $user): static
  450.     {
  451.         if (!$this->users->contains($user)) {
  452.             $this->users->add($user);
  453.             $user->setStore($this);
  454.         }
  456.         return $this;
  457.     }
  459.     public function removeUser(User $user): static
  460.     {
  461.         if ($this->users->removeElement($user)) {
  462.             // set the owning side to null (unless already changed)
  463.             if ($user->getStore() === $this) {
  464.                 $user->setStore(null);
  465.             }
  466.         }
  468.         return $this;
  469.     }
  470. }