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(type: Types::DATETIME_MUTABLE, nullable: true)]
  37.     private ?\DateTimeInterface $createdAt = null;
  39.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  40.     private ?string $description = null;
  42.     #[ORM\ManyToOne(inversedBy: 'stores')]
  43.     #[ORM\JoinColumn(nullable: false)]
  44.     private ?City $city = null;
  46.     #[ORM\OneToOne(cascade: ['persist', 'remove'])]
  47.     #[ORM\JoinColumn(nullable: false)]
  48.     #[Assert\Valid]
  49.     private ?User $user = null;
  51.     #[ORM\ManyToOne(inversedBy: 'stores')]
  52.     #[ORM\JoinColumn(nullable: true)]
  53.     private ?CityRegion $cityRegion = null;
  55.     #[ORM\Column(length: 255, nullable: true)]
  56.     private ?string $storeType = null;
  58.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: CashBox::class)]
  59.     private Collection $cashBoxes;
  61.     #[ORM\OneToMany(mappedBy: 'collectedByStore', targetEntity: Shipment::class)]
  62.     private Collection $collectedShipments;
  64.     #[ORM\OneToMany(mappedBy: 'shippedByStore', targetEntity: Shipment::class)]
  65.     private Collection $shippedShipments;
  67.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Product::class)]
  68.     private Collection $products;
  70.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Order::class)]
  71.     private Collection $orders;
  73.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Agent::class)]
  74.     private Collection $agents;
  76.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Customer::class)]
  77.     private Collection $customers;
  80.     #[ORM\Column(nullable: true)]
  81.     private ?\DateTimeImmutable $deletedAt = null;
  83.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: User::class)]
  84.     private Collection $users;
  88.     public function __toString()
  89.     {
  90.         return (string)$this->name;
  91.     }
  93.     public function __construct()
  94.     {
  95.         $this->user = new User();
  96.         $this->cashBoxes = new ArrayCollection();
  97.         $this->collectedShipments = new ArrayCollection();
  98.         $this->shippedShipments = new ArrayCollection();
  99.         $this->products = new ArrayCollection();
  100.         $this->orders = new ArrayCollection();
  101.         $this->agents = new ArrayCollection();
  102.         $this->customers = new ArrayCollection();
  103.         $this->users = new ArrayCollection();
  104.     }
  106.     public function getId(): ?int
  107.     {
  108.         return $this->id;
  109.     }
  111.     public function getName(): ?string
  112.     {
  113.         return $this->name;
  114.     }
  116.     public function setName(string $name): self
  117.     {
  118.         $this->name = $name;
  120.         return $this;
  121.     }
  123.     public function getCreatedAt(): ?\DateTimeInterface
  124.     {
  125.         return $this->createdAt;
  126.     }
  128.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  129.     {
  130.         $this->createdAt = $createdAt;
  132.         return $this;
  133.     }
  135.     public function getDescription(): ?string
  136.     {
  137.         return $this->description;
  138.     }
  140.     public function setDescription(?string $description): self
  141.     {
  142.         $this->description = $description;
  144.         return $this;
  145.     }
  147.     public function getCity(): ?City
  148.     {
  149.         return $this->city;
  150.     }
  152.     public function setCity(?City $city): self
  153.     {
  154.         $this->city = $city;
  156.         return $this;
  157.     }
  159.     public function getUser(): ?User
  160.     {
  161.         return $this->user;
  162.     }
  164.     public function setUser(User $user): self
  165.     {
  166.         $this->user = $user;
  168.         return $this;
  169.     }
  171.     public function getCityRegion(): ?CityRegion
  172.     {
  173.         return $this->cityRegion;
  174.     }
  176.     public function setCityRegion(?CityRegion $cityRegion): self
  177.     {
  178.         $this->cityRegion = $cityRegion;
  180.         return $this;
  181.     }
  183.     public function getStoreType(): ?string
  184.     {
  185.         return $this->storeType;
  186.     }
  188.     public function setStoreType(?string $storeType): self
  189.     {
  190.         $this->storeType = $storeType;
  192.         return $this;
  193.     }
  195.     /**
  196.      * @return Collection<int, CashBox>
  197.      */
  198.     public function getCashBoxes(): Collection
  199.     {
  200.         return $this->cashBoxes;
  201.     }
  203.     public function addCashBox(CashBox $cashBox): self
  204.     {
  205.         if (!$this->cashBoxes->contains($cashBox)) {
  206.             $this->cashBoxes->add($cashBox);
  207.             $cashBox->setStore($this);
  208.         }
  210.         return $this;
  211.     }
  213.     public function removeCashBox(CashBox $cashBox): self
  214.     {
  215.         if ($this->cashBoxes->removeElement($cashBox)) {
  216.             // set the owning side to null (unless already changed)
  217.             if ($cashBox->getStore() === $this) {
  218.                 $cashBox->setStore(null);
  219.             }
  220.         }
  222.         return $this;
  223.     }
  225.     /**
  226.      * @return Collection<int, Shipment>
  227.      */
  228.     public function getCollectedShipments(): Collection
  229.     {
  230.         return $this->collectedShipments;
  231.     }
  233.     public function addCollectedShipment(Shipment $collectedShipment): self
  234.     {
  235.         if (!$this->collectedShipments->contains($collectedShipment)) {
  236.             $this->collectedShipments->add($collectedShipment);
  237.             $collectedShipment->setCollectedByStore($this);
  238.         }
  240.         return $this;
  241.     }
  243.     public function removeCollectedShipment(Shipment $collectedShipment): self
  244.     {
  245.         if ($this->collectedShipments->removeElement($collectedShipment)) {
  246.             // set the owning side to null (unless already changed)
  247.             if ($collectedShipment->getCollectedByStore() === $this) {
  248.                 $collectedShipment->setCollectedByStore(null);
  249.             }
  250.         }
  252.         return $this;
  253.     }
  255.     /**
  256.      * @return Collection<int, Shipment>
  257.      */
  258.     public function getShippedShipments(): Collection
  259.     {
  260.         return $this->shippedShipments;
  261.     }
  263.     public function addShippedShipment(Shipment $shippedShipment): self
  264.     {
  265.         if (!$this->shippedShipments->contains($shippedShipment)) {
  266.             $this->shippedShipments->add($shippedShipment);
  267.             $shippedShipment->setShippedByStore($this);
  268.         }
  270.         return $this;
  271.     }
  273.     public function removeShippedShipment(Shipment $shippedShipment): self
  274.     {
  275.         if ($this->shippedShipments->removeElement($shippedShipment)) {
  276.             // set the owning side to null (unless already changed)
  277.             if ($shippedShipment->getShippedByStore() === $this) {
  278.                 $shippedShipment->setShippedByStore(null);
  279.             }
  280.         }
  282.         return $this;
  283.     }
  285.     /**
  286.      * @return Collection<int, Product>
  287.      */
  288.     public function getProducts(): Collection
  289.     {
  290.         return $this->products;
  291.     }
  293.     public function addProduct(Product $product): self
  294.     {
  295.         if (!$this->products->contains($product)) {
  296.             $this->products->add($product);
  297.             $product->setStore($this);
  298.         }
  300.         return $this;
  301.     }
  303.     public function removeProduct(Product $product): self
  304.     {
  305.         if ($this->products->removeElement($product)) {
  306.             // set the owning side to null (unless already changed)
  307.             if ($product->getStore() === $this) {
  308.                 $product->setStore(null);
  309.             }
  310.         }
  312.         return $this;
  313.     }
  315.     /**
  316.      * @return Collection<int, Order>
  317.      */
  318.     public function getOrders(): Collection
  319.     {
  320.         return $this->orders;
  321.     }
  323.     public function addOrder(Order $order): self
  324.     {
  325.         if (!$this->orders->contains($order)) {
  326.             $this->orders->add($order);
  327.             $order->setStore($this);
  328.         }
  330.         return $this;
  331.     }
  333.     public function removeOrder(Order $order): self
  334.     {
  335.         if ($this->orders->removeElement($order)) {
  336.             // set the owning side to null (unless already changed)
  337.             if ($order->getStore() === $this) {
  338.                 $order->setStore(null);
  339.             }
  340.         }
  342.         return $this;
  343.     }
  345.     /**
  346.      * @return Collection<int, Agent>
  347.      */
  348.     public function getAgents(): Collection
  349.     {
  350.         return $this->agents;
  351.     }
  353.     public function addAgent(Agent $agent): self
  354.     {
  355.         if (!$this->agents->contains($agent)) {
  356.             $this->agents->add($agent);
  357.             $agent->setStore($this);
  358.         }
  360.         return $this;
  361.     }
  363.     public function removeAgent(Agent $agent): self
  364.     {
  365.         if ($this->agents->removeElement($agent)) {
  366.             // set the owning side to null (unless already changed)
  367.             if ($agent->getStore() === $this) {
  368.                 $agent->setStore(null);
  369.             }
  370.         }
  372.         return $this;
  373.     }
  375.     /**
  376.      * @return Collection<int, Customer>
  377.      */
  378.     public function getCustomers(): Collection
  379.     {
  380.         return $this->customers;
  381.     }
  383.     public function addCustomer(Customer $customer): self
  384.     {
  385.         if (!$this->customers->contains($customer)) {
  386.             $this->customers->add($customer);
  387.             $customer->setStore($this);
  388.         }
  390.         return $this;
  391.     }
  393.     public function removeCustomer(Customer $customer): self
  394.     {
  395.         if ($this->customers->removeElement($customer)) {
  396.             // set the owning side to null (unless already changed)
  397.             if ($customer->getStore() === $this) {
  398.                 $customer->setStore(null);
  399.             }
  400.         }
  402.         return $this;
  403.     }
  405.         /**
  406.      * Get the value of deletedAt
  407.      */ 
  408.     public function getDeletedAt()
  409.     {
  410.         return $this->deletedAt;
  411.     }
  413.     /**
  414.      * Set the value of deletedAt
  415.      *
  416.      * @return  self
  417.      */ 
  418.     public function setDeletedAt($deletedAt)
  419.     {
  420.         $this->deletedAt = $deletedAt;
  422.         return $this;
  423.     }
  425.     /**
  426.      * @return Collection<int, User>
  427.      */
  428.     public function getUsers(): Collection
  429.     {
  430.         return $this->users;
  431.     }
  433.     public function addUser(User $user): static
  434.     {
  435.         if (!$this->users->contains($user)) {
  436.             $this->users->add($user);
  437.             $user->setStore($this);
  438.         }
  440.         return $this;
  441.     }
  443.     public function removeUser(User $user): static
  444.     {
  445.         if ($this->users->removeElement($user)) {
  446.             // set the owning side to null (unless already changed)
  447.             if ($user->getStore() === $this) {
  448.                 $user->setStore(null);
  449.             }
  450.         }
  452.         return $this;
  453.     }
  454. }