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

  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;
  22. #[ORM\Entity(repositoryClass: StoreRepository::class)]
  23. #[ApiResource]
  24. class Store
  25. {
  26.     #[ORM\Id]
  27.     #[ORM\GeneratedValue]
  28.     #[ORM\Column]
  29.     private ?int $id = null;
  31.     #[ORM\Column(length: 255)]
  32.     private ?string $name = null;
  34.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  35.     private ?\DateTimeInterface $createdAt = null;
  37.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  38.     private ?string $description = null;
  40.     #[ORM\ManyToOne(inversedBy: 'stores')]
  41.     #[ORM\JoinColumn(nullable: false)]
  42.     private ?City $city = null;
  44.     #[ORM\OneToOne(cascade: ['persist', 'remove'])]
  45.     #[ORM\JoinColumn(nullable: false)]
  46.     #[Assert\Valid]
  47.     private ?User $user = null;
  49.     #[ORM\ManyToOne(inversedBy: 'stores')]
  50.     #[ORM\JoinColumn(nullable: true)]
  51.     private ?CityRegion $cityRegion = null;
  53.     #[ORM\Column(length: 255, nullable: true)]
  54.     private ?string $storeType = null;
  56.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: CashBox::class)]
  57.     private Collection $cashBoxes;
  59.     #[ORM\OneToMany(mappedBy: 'collectedByStore', targetEntity: Shipment::class)]
  60.     private Collection $collectedShipments;
  62.     #[ORM\OneToMany(mappedBy: 'shippedByStore', targetEntity: Shipment::class)]
  63.     private Collection $shippedShipments;
  65.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Product::class)]
  66.     private Collection $products;
  68.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Order::class)]
  69.     private Collection $orders;
  71.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Agent::class)]
  72.     private Collection $agents;
  74.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Customer::class)]
  75.     private Collection $customers;
  80.     public function __toString()
  81.     {
  82.         return (string)$this->name;
  83.     }
  85.     public function __construct()
  86.     {
  87.         $this->user = new User();
  88.         $this->cashBoxes = new ArrayCollection();
  89.         $this->collectedShipments = new ArrayCollection();
  90.         $this->shippedShipments = new ArrayCollection();
  91.         $this->products = new ArrayCollection();
  92.         $this->orders = new ArrayCollection();
  93.         $this->agents = new ArrayCollection();
  94.         $this->customers = new ArrayCollection();
  95.     }
  97.     public function getId(): ?int
  98.     {
  99.         return $this->id;
  100.     }
  102.     public function getName(): ?string
  103.     {
  104.         return $this->name;
  105.     }
  107.     public function setName(string $name): self
  108.     {
  109.         $this->name = $name;
  111.         return $this;
  112.     }
  114.     public function getCreatedAt(): ?\DateTimeInterface
  115.     {
  116.         return $this->createdAt;
  117.     }
  119.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  120.     {
  121.         $this->createdAt = $createdAt;
  123.         return $this;
  124.     }
  126.     public function getDescription(): ?string
  127.     {
  128.         return $this->description;
  129.     }
  131.     public function setDescription(?string $description): self
  132.     {
  133.         $this->description = $description;
  135.         return $this;
  136.     }
  138.     public function getCity(): ?City
  139.     {
  140.         return $this->city;
  141.     }
  143.     public function setCity(?City $city): self
  144.     {
  145.         $this->city = $city;
  147.         return $this;
  148.     }
  150.     public function getUser(): ?User
  151.     {
  152.         return $this->user;
  153.     }
  155.     public function setUser(User $user): self
  156.     {
  157.         $this->user = $user;
  159.         return $this;
  160.     }
  162.     public function getCityRegion(): ?CityRegion
  163.     {
  164.         return $this->cityRegion;
  165.     }
  167.     public function setCityRegion(?CityRegion $cityRegion): self
  168.     {
  169.         $this->cityRegion = $cityRegion;
  171.         return $this;
  172.     }
  174.     public function getStoreType(): ?string
  175.     {
  176.         return $this->storeType;
  177.     }
  179.     public function setStoreType(?string $storeType): self
  180.     {
  181.         $this->storeType = $storeType;
  183.         return $this;
  184.     }
  186.     /**
  187.      * @return Collection<int, CashBox>
  188.      */
  189.     public function getCashBoxes(): Collection
  190.     {
  191.         return $this->cashBoxes;
  192.     }
  194.     public function addCashBox(CashBox $cashBox): self
  195.     {
  196.         if (!$this->cashBoxes->contains($cashBox)) {
  197.             $this->cashBoxes->add($cashBox);
  198.             $cashBox->setStore($this);
  199.         }
  201.         return $this;
  202.     }
  204.     public function removeCashBox(CashBox $cashBox): self
  205.     {
  206.         if ($this->cashBoxes->removeElement($cashBox)) {
  207.             // set the owning side to null (unless already changed)
  208.             if ($cashBox->getStore() === $this) {
  209.                 $cashBox->setStore(null);
  210.             }
  211.         }
  213.         return $this;
  214.     }
  216.     /**
  217.      * @return Collection<int, Shipment>
  218.      */
  219.     public function getCollectedShipments(): Collection
  220.     {
  221.         return $this->collectedShipments;
  222.     }
  224.     public function addCollectedShipment(Shipment $collectedShipment): self
  225.     {
  226.         if (!$this->collectedShipments->contains($collectedShipment)) {
  227.             $this->collectedShipments->add($collectedShipment);
  228.             $collectedShipment->setCollectedByStore($this);
  229.         }
  231.         return $this;
  232.     }
  234.     public function removeCollectedShipment(Shipment $collectedShipment): self
  235.     {
  236.         if ($this->collectedShipments->removeElement($collectedShipment)) {
  237.             // set the owning side to null (unless already changed)
  238.             if ($collectedShipment->getCollectedByStore() === $this) {
  239.                 $collectedShipment->setCollectedByStore(null);
  240.             }
  241.         }
  243.         return $this;
  244.     }
  246.     /**
  247.      * @return Collection<int, Shipment>
  248.      */
  249.     public function getShippedShipments(): Collection
  250.     {
  251.         return $this->shippedShipments;
  252.     }
  254.     public function addShippedShipment(Shipment $shippedShipment): self
  255.     {
  256.         if (!$this->shippedShipments->contains($shippedShipment)) {
  257.             $this->shippedShipments->add($shippedShipment);
  258.             $shippedShipment->setShippedByStore($this);
  259.         }
  261.         return $this;
  262.     }
  264.     public function removeShippedShipment(Shipment $shippedShipment): self
  265.     {
  266.         if ($this->shippedShipments->removeElement($shippedShipment)) {
  267.             // set the owning side to null (unless already changed)
  268.             if ($shippedShipment->getShippedByStore() === $this) {
  269.                 $shippedShipment->setShippedByStore(null);
  270.             }
  271.         }
  273.         return $this;
  274.     }
  276.     /**
  277.      * @return Collection<int, Product>
  278.      */
  279.     public function getProducts(): Collection
  280.     {
  281.         return $this->products;
  282.     }
  284.     public function addProduct(Product $product): self
  285.     {
  286.         if (!$this->products->contains($product)) {
  287.             $this->products->add($product);
  288.             $product->setStore($this);
  289.         }
  291.         return $this;
  292.     }
  294.     public function removeProduct(Product $product): self
  295.     {
  296.         if ($this->products->removeElement($product)) {
  297.             // set the owning side to null (unless already changed)
  298.             if ($product->getStore() === $this) {
  299.                 $product->setStore(null);
  300.             }
  301.         }
  303.         return $this;
  304.     }
  306.     /**
  307.      * @return Collection<int, Order>
  308.      */
  309.     public function getOrders(): Collection
  310.     {
  311.         return $this->orders;
  312.     }
  314.     public function addOrder(Order $order): self
  315.     {
  316.         if (!$this->orders->contains($order)) {
  317.             $this->orders->add($order);
  318.             $order->setStore($this);
  319.         }
  321.         return $this;
  322.     }
  324.     public function removeOrder(Order $order): self
  325.     {
  326.         if ($this->orders->removeElement($order)) {
  327.             // set the owning side to null (unless already changed)
  328.             if ($order->getStore() === $this) {
  329.                 $order->setStore(null);
  330.             }
  331.         }
  333.         return $this;
  334.     }
  336.     /**
  337.      * @return Collection<int, Agent>
  338.      */
  339.     public function getAgents(): Collection
  340.     {
  341.         return $this->agents;
  342.     }
  344.     public function addAgent(Agent $agent): self
  345.     {
  346.         if (!$this->agents->contains($agent)) {
  347.             $this->agents->add($agent);
  348.             $agent->setStore($this);
  349.         }
  351.         return $this;
  352.     }
  354.     public function removeAgent(Agent $agent): self
  355.     {
  356.         if ($this->agents->removeElement($agent)) {
  357.             // set the owning side to null (unless already changed)
  358.             if ($agent->getStore() === $this) {
  359.                 $agent->setStore(null);
  360.             }
  361.         }
  363.         return $this;
  364.     }
  366.     /**
  367.      * @return Collection<int, Customer>
  368.      */
  369.     public function getCustomers(): Collection
  370.     {
  371.         return $this->customers;
  372.     }
  374.     public function addCustomer(Customer $customer): self
  375.     {
  376.         if (!$this->customers->contains($customer)) {
  377.             $this->customers->add($customer);
  378.             $customer->setStore($this);
  379.         }
  381.         return $this;
  382.     }
  384.     public function removeCustomer(Customer $customer): self
  385.     {
  386.         if ($this->customers->removeElement($customer)) {
  387.             // set the owning side to null (unless already changed)
  388.             if ($customer->getStore() === $this) {
  389.                 $customer->setStore(null);
  390.             }
  391.         }
  393.         return $this;
  394.     }
  395. }