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

  1. <?php
  3. namespace App\Flexy\ShopBundle\Entity\Store;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use App\Entity\User;
  7. use App\Flexy\ShopBundle\Entity\Customer\Customer;
  8. use App\Flexy\ShopBundle\Entity\Order\Order;
  9. use App\Flexy\ShopBundle\Entity\Product\Product;
  10. use App\Flexy\ShopBundle\Entity\Resource\Agent;
  11. use App\Flexy\ShopBundle\Entity\Shipping\City;
  12. use App\Flexy\ShopBundle\Entity\Shipping\CityRegion;
  13. use App\Flexy\ShopBundle\Entity\Shipping\Shipment;
  14. use App\Flexy\ShopBundle\Entity\Shipping\CashBox;
  15. use App\Repository\Flexy\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;
  85.     public function __toString()
  86.     {
  87.         return (string)$this->name;
  88.     }
  90.     public function __construct()
  91.     {
  92.         $this->user = new User();
  93.         $this->cashBoxes = new ArrayCollection();
  94.         $this->collectedShipments = new ArrayCollection();
  95.         $this->shippedShipments = new ArrayCollection();
  96.         $this->products = new ArrayCollection();
  97.         $this->orders = new ArrayCollection();
  98.         $this->agents = new ArrayCollection();
  99.         $this->customers = new ArrayCollection();
  100.     }
  102.     public function getId(): ?int
  103.     {
  104.         return $this->id;
  105.     }
  107.     public function getName(): ?string
  108.     {
  109.         return $this->name;
  110.     }
  112.     public function setName(string $name): self
  113.     {
  114.         $this->name = $name;
  116.         return $this;
  117.     }
  119.     public function getCreatedAt(): ?\DateTimeInterface
  120.     {
  121.         return $this->createdAt;
  122.     }
  124.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  125.     {
  126.         $this->createdAt = $createdAt;
  128.         return $this;
  129.     }
  131.     public function getDescription(): ?string
  132.     {
  133.         return $this->description;
  134.     }
  136.     public function setDescription(?string $description): self
  137.     {
  138.         $this->description = $description;
  140.         return $this;
  141.     }
  143.     public function getCity(): ?City
  144.     {
  145.         return $this->city;
  146.     }
  148.     public function setCity(?City $city): self
  149.     {
  150.         $this->city = $city;
  152.         return $this;
  153.     }
  155.     public function getUser(): ?User
  156.     {
  157.         return $this->user;
  158.     }
  160.     public function setUser(User $user): self
  161.     {
  162.         $this->user = $user;
  164.         return $this;
  165.     }
  167.     public function getCityRegion(): ?CityRegion
  168.     {
  169.         return $this->cityRegion;
  170.     }
  172.     public function setCityRegion(?CityRegion $cityRegion): self
  173.     {
  174.         $this->cityRegion = $cityRegion;
  176.         return $this;
  177.     }
  179.     public function getStoreType(): ?string
  180.     {
  181.         return $this->storeType;
  182.     }
  184.     public function setStoreType(?string $storeType): self
  185.     {
  186.         $this->storeType = $storeType;
  188.         return $this;
  189.     }
  191.     /**
  192.      * @return Collection<int, CashBox>
  193.      */
  194.     public function getCashBoxes(): Collection
  195.     {
  196.         return $this->cashBoxes;
  197.     }
  199.     public function addCashBox(CashBox $cashBox): self
  200.     {
  201.         if (!$this->cashBoxes->contains($cashBox)) {
  202.             $this->cashBoxes->add($cashBox);
  203.             $cashBox->setStore($this);
  204.         }
  206.         return $this;
  207.     }
  209.     public function removeCashBox(CashBox $cashBox): self
  210.     {
  211.         if ($this->cashBoxes->removeElement($cashBox)) {
  212.             // set the owning side to null (unless already changed)
  213.             if ($cashBox->getStore() === $this) {
  214.                 $cashBox->setStore(null);
  215.             }
  216.         }
  218.         return $this;
  219.     }
  221.     /**
  222.      * @return Collection<int, Shipment>
  223.      */
  224.     public function getCollectedShipments(): Collection
  225.     {
  226.         return $this->collectedShipments;
  227.     }
  229.     public function addCollectedShipment(Shipment $collectedShipment): self
  230.     {
  231.         if (!$this->collectedShipments->contains($collectedShipment)) {
  232.             $this->collectedShipments->add($collectedShipment);
  233.             $collectedShipment->setCollectedByStore($this);
  234.         }
  236.         return $this;
  237.     }
  239.     public function removeCollectedShipment(Shipment $collectedShipment): self
  240.     {
  241.         if ($this->collectedShipments->removeElement($collectedShipment)) {
  242.             // set the owning side to null (unless already changed)
  243.             if ($collectedShipment->getCollectedByStore() === $this) {
  244.                 $collectedShipment->setCollectedByStore(null);
  245.             }
  246.         }
  248.         return $this;
  249.     }
  251.     /**
  252.      * @return Collection<int, Shipment>
  253.      */
  254.     public function getShippedShipments(): Collection
  255.     {
  256.         return $this->shippedShipments;
  257.     }
  259.     public function addShippedShipment(Shipment $shippedShipment): self
  260.     {
  261.         if (!$this->shippedShipments->contains($shippedShipment)) {
  262.             $this->shippedShipments->add($shippedShipment);
  263.             $shippedShipment->setShippedByStore($this);
  264.         }
  266.         return $this;
  267.     }
  269.     public function removeShippedShipment(Shipment $shippedShipment): self
  270.     {
  271.         if ($this->shippedShipments->removeElement($shippedShipment)) {
  272.             // set the owning side to null (unless already changed)
  273.             if ($shippedShipment->getShippedByStore() === $this) {
  274.                 $shippedShipment->setShippedByStore(null);
  275.             }
  276.         }
  278.         return $this;
  279.     }
  281.     /**
  282.      * @return Collection<int, Product>
  283.      */
  284.     public function getProducts(): Collection
  285.     {
  286.         return $this->products;
  287.     }
  289.     public function addProduct(Product $product): self
  290.     {
  291.         if (!$this->products->contains($product)) {
  292.             $this->products->add($product);
  293.             $product->setStore($this);
  294.         }
  296.         return $this;
  297.     }
  299.     public function removeProduct(Product $product): self
  300.     {
  301.         if ($this->products->removeElement($product)) {
  302.             // set the owning side to null (unless already changed)
  303.             if ($product->getStore() === $this) {
  304.                 $product->setStore(null);
  305.             }
  306.         }
  308.         return $this;
  309.     }
  311.     /**
  312.      * @return Collection<int, Order>
  313.      */
  314.     public function getOrders(): Collection
  315.     {
  316.         return $this->orders;
  317.     }
  319.     public function addOrder(Order $order): self
  320.     {
  321.         if (!$this->orders->contains($order)) {
  322.             $this->orders->add($order);
  323.             $order->setStore($this);
  324.         }
  326.         return $this;
  327.     }
  329.     public function removeOrder(Order $order): self
  330.     {
  331.         if ($this->orders->removeElement($order)) {
  332.             // set the owning side to null (unless already changed)
  333.             if ($order->getStore() === $this) {
  334.                 $order->setStore(null);
  335.             }
  336.         }
  338.         return $this;
  339.     }
  341.     /**
  342.      * @return Collection<int, Agent>
  343.      */
  344.     public function getAgents(): Collection
  345.     {
  346.         return $this->agents;
  347.     }
  349.     public function addAgent(Agent $agent): self
  350.     {
  351.         if (!$this->agents->contains($agent)) {
  352.             $this->agents->add($agent);
  353.             $agent->setStore($this);
  354.         }
  356.         return $this;
  357.     }
  359.     public function removeAgent(Agent $agent): self
  360.     {
  361.         if ($this->agents->removeElement($agent)) {
  362.             // set the owning side to null (unless already changed)
  363.             if ($agent->getStore() === $this) {
  364.                 $agent->setStore(null);
  365.             }
  366.         }
  368.         return $this;
  369.     }
  371.     /**
  372.      * @return Collection<int, Customer>
  373.      */
  374.     public function getCustomers(): Collection
  375.     {
  376.         return $this->customers;
  377.     }
  379.     public function addCustomer(Customer $customer): self
  380.     {
  381.         if (!$this->customers->contains($customer)) {
  382.             $this->customers->add($customer);
  383.             $customer->setStore($this);
  384.         }
  386.         return $this;
  387.     }
  389.     public function removeCustomer(Customer $customer): self
  390.     {
  391.         if ($this->customers->removeElement($customer)) {
  392.             // set the owning side to null (unless already changed)
  393.             if ($customer->getStore() === $this) {
  394.                 $customer->setStore(null);
  395.             }
  396.         }
  398.         return $this;
  399.     }
  401.         /**
  402.      * Get the value of deletedAt
  403.      */ 
  404.     public function getDeletedAt()
  405.     {
  406.         return $this->deletedAt;
  407.     }
  409.     /**
  410.      * Set the value of deletedAt
  411.      *
  412.      * @return  self
  413.      */ 
  414.     public function setDeletedAt($deletedAt)
  415.     {
  416.         $this->deletedAt = $deletedAt;
  418.         return $this;
  419.     }
  420. }