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\Customer\Visit;
  9. use App\Flexy\ShopBundle\Entity\Order\CashBoxOrder;
  10. use App\Flexy\ShopBundle\Entity\Order\Order;
  11. use App\Flexy\ShopBundle\Entity\Product\Product;
  12. use App\Flexy\ShopBundle\Entity\Resource\Agent;
  13. use App\Flexy\ShopBundle\Entity\Shipping\City;
  14. use App\Flexy\ShopBundle\Entity\Shipping\CityRegion;
  15. use App\Flexy\ShopBundle\Entity\Shipping\Shipment;
  16. use App\Flexy\ShopBundle\Entity\Shipping\CashBox;
  17. use App\Repository\Flexy\ShopBundle\Entity\Store\StoreRepository;
  18. use Doctrine\Common\Collections\ArrayCollection;
  19. use Doctrine\Common\Collections\Collection;
  20. use Doctrine\DBAL\Types\Types;
  21. use Doctrine\ORM\Mapping as ORM;
  22. use Symfony\Component\Validator\Constraints as Assert;
  24. #[ORM\Entity(repositoryClass: StoreRepository::class)]
  25. #[ApiResource]
  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;
  79.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: CashBoxOrder::class)]
  80.     private Collection $cashBoxOrders;
  82.     #[ORM\OneToMany(mappedBy: 'store', targetEntity: Visit::class)]
  83.     private Collection $visits;
  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->cashBoxOrders = new ArrayCollection();
  104.         $this->visits = new ArrayCollection();
  105.     }
  107.     public function getId(): ?int
  108.     {
  109.         return $this->id;
  110.     }
  112.     public function getName(): ?string
  113.     {
  114.         return $this->name;
  115.     }
  117.     public function setName(string $name): self
  118.     {
  119.         $this->name = $name;
  121.         return $this;
  122.     }
  124.     public function getCreatedAt(): ?\DateTimeInterface
  125.     {
  126.         return $this->createdAt;
  127.     }
  129.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  130.     {
  131.         $this->createdAt = $createdAt;
  133.         return $this;
  134.     }
  136.     public function getDescription(): ?string
  137.     {
  138.         return $this->description;
  139.     }
  141.     public function setDescription(?string $description): self
  142.     {
  143.         $this->description = $description;
  145.         return $this;
  146.     }
  148.     public function getCity(): ?City
  149.     {
  150.         return $this->city;
  151.     }
  153.     public function setCity(?City $city): self
  154.     {
  155.         $this->city = $city;
  157.         return $this;
  158.     }
  160.     public function getUser(): ?User
  161.     {
  162.         return $this->user;
  163.     }
  165.     public function setUser(User $user): self
  166.     {
  167.         $this->user = $user;
  169.         return $this;
  170.     }
  172.     public function getCityRegion(): ?CityRegion
  173.     {
  174.         return $this->cityRegion;
  175.     }
  177.     public function setCityRegion(?CityRegion $cityRegion): self
  178.     {
  179.         $this->cityRegion = $cityRegion;
  181.         return $this;
  182.     }
  184.     public function getStoreType(): ?string
  185.     {
  186.         return $this->storeType;
  187.     }
  189.     public function setStoreType(?string $storeType): self
  190.     {
  191.         $this->storeType = $storeType;
  193.         return $this;
  194.     }
  196.     /**
  197.      * @return Collection<int, CashBox>
  198.      */
  199.     public function getCashBoxes(): Collection
  200.     {
  201.         return $this->cashBoxes;
  202.     }
  204.     public function addCashBox(CashBox $cashBox): self
  205.     {
  206.         if (!$this->cashBoxes->contains($cashBox)) {
  207.             $this->cashBoxes->add($cashBox);
  208.             $cashBox->setStore($this);
  209.         }
  211.         return $this;
  212.     }
  214.     public function removeCashBox(CashBox $cashBox): self
  215.     {
  216.         if ($this->cashBoxes->removeElement($cashBox)) {
  217.             // set the owning side to null (unless already changed)
  218.             if ($cashBox->getStore() === $this) {
  219.                 $cashBox->setStore(null);
  220.             }
  221.         }
  223.         return $this;
  224.     }
  226.     /**
  227.      * @return Collection<int, Shipment>
  228.      */
  229.     public function getCollectedShipments(): Collection
  230.     {
  231.         return $this->collectedShipments;
  232.     }
  234.     public function addCollectedShipment(Shipment $collectedShipment): self
  235.     {
  236.         if (!$this->collectedShipments->contains($collectedShipment)) {
  237.             $this->collectedShipments->add($collectedShipment);
  238.             $collectedShipment->setCollectedByStore($this);
  239.         }
  241.         return $this;
  242.     }
  244.     public function removeCollectedShipment(Shipment $collectedShipment): self
  245.     {
  246.         if ($this->collectedShipments->removeElement($collectedShipment)) {
  247.             // set the owning side to null (unless already changed)
  248.             if ($collectedShipment->getCollectedByStore() === $this) {
  249.                 $collectedShipment->setCollectedByStore(null);
  250.             }
  251.         }
  253.         return $this;
  254.     }
  256.     /**
  257.      * @return Collection<int, Shipment>
  258.      */
  259.     public function getShippedShipments(): Collection
  260.     {
  261.         return $this->shippedShipments;
  262.     }
  264.     public function addShippedShipment(Shipment $shippedShipment): self
  265.     {
  266.         if (!$this->shippedShipments->contains($shippedShipment)) {
  267.             $this->shippedShipments->add($shippedShipment);
  268.             $shippedShipment->setShippedByStore($this);
  269.         }
  271.         return $this;
  272.     }
  274.     public function removeShippedShipment(Shipment $shippedShipment): self
  275.     {
  276.         if ($this->shippedShipments->removeElement($shippedShipment)) {
  277.             // set the owning side to null (unless already changed)
  278.             if ($shippedShipment->getShippedByStore() === $this) {
  279.                 $shippedShipment->setShippedByStore(null);
  280.             }
  281.         }
  283.         return $this;
  284.     }
  286.     /**
  287.      * @return Collection<int, Product>
  288.      */
  289.     public function getProducts(): Collection
  290.     {
  291.         return $this->products;
  292.     }
  294.     public function addProduct(Product $product): self
  295.     {
  296.         if (!$this->products->contains($product)) {
  297.             $this->products->add($product);
  298.             $product->setStore($this);
  299.         }
  301.         return $this;
  302.     }
  304.     public function removeProduct(Product $product): self
  305.     {
  306.         if ($this->products->removeElement($product)) {
  307.             // set the owning side to null (unless already changed)
  308.             if ($product->getStore() === $this) {
  309.                 $product->setStore(null);
  310.             }
  311.         }
  313.         return $this;
  314.     }
  316.     /**
  317.      * @return Collection<int, Order>
  318.      */
  319.     public function getOrders(): Collection
  320.     {
  321.         return $this->orders;
  322.     }
  324.     public function addOrder(Order $order): self
  325.     {
  326.         if (!$this->orders->contains($order)) {
  327.             $this->orders->add($order);
  328.             $order->setStore($this);
  329.         }
  331.         return $this;
  332.     }
  334.     public function removeOrder(Order $order): self
  335.     {
  336.         if ($this->orders->removeElement($order)) {
  337.             // set the owning side to null (unless already changed)
  338.             if ($order->getStore() === $this) {
  339.                 $order->setStore(null);
  340.             }
  341.         }
  343.         return $this;
  344.     }
  346.     /**
  347.      * @return Collection<int, Agent>
  348.      */
  349.     public function getAgents(): Collection
  350.     {
  351.         return $this->agents;
  352.     }
  354.     public function addAgent(Agent $agent): self
  355.     {
  356.         if (!$this->agents->contains($agent)) {
  357.             $this->agents->add($agent);
  358.             $agent->setStore($this);
  359.         }
  361.         return $this;
  362.     }
  364.     public function removeAgent(Agent $agent): self
  365.     {
  366.         if ($this->agents->removeElement($agent)) {
  367.             // set the owning side to null (unless already changed)
  368.             if ($agent->getStore() === $this) {
  369.                 $agent->setStore(null);
  370.             }
  371.         }
  373.         return $this;
  374.     }
  376.     /**
  377.      * @return Collection<int, Customer>
  378.      */
  379.     public function getCustomers(): Collection
  380.     {
  381.         return $this->customers;
  382.     }
  384.     public function addCustomer(Customer $customer): self
  385.     {
  386.         if (!$this->customers->contains($customer)) {
  387.             $this->customers->add($customer);
  388.             $customer->setStore($this);
  389.         }
  391.         return $this;
  392.     }
  394.     public function removeCustomer(Customer $customer): self
  395.     {
  396.         if ($this->customers->removeElement($customer)) {
  397.             // set the owning side to null (unless already changed)
  398.             if ($customer->getStore() === $this) {
  399.                 $customer->setStore(null);
  400.             }
  401.         }
  403.         return $this;
  404.     }
  406.     /**
  407.      * @return Collection<int, CashBoxOrder>
  408.      */
  409.     public function getCashBoxOrders(): Collection
  410.     {
  411.         return $this->cashBoxOrders;
  412.     }
  414.     public function addCashBoxOrder(CashBoxOrder $cashBoxOrder): self
  415.     {
  416.         if (!$this->cashBoxOrders->contains($cashBoxOrder)) {
  417.             $this->cashBoxOrders->add($cashBoxOrder);
  418.             $cashBoxOrder->setStore($this);
  419.         }
  421.         return $this;
  422.     }
  424.     public function removeCashBoxOrder(CashBoxOrder $cashBoxOrder): self
  425.     {
  426.         if ($this->cashBoxOrders->removeElement($cashBoxOrder)) {
  427.             // set the owning side to null (unless already changed)
  428.             if ($cashBoxOrder->getStore() === $this) {
  429.                 $cashBoxOrder->setStore(null);
  430.             }
  431.         }
  433.         return $this;
  434.     }
  436.     /**
  437.      * @return Collection<int, Visit>
  438.      */
  439.     public function getVisits(): Collection
  440.     {
  441.         return $this->visits;
  442.     }
  444.     public function addVisit(Visit $visit): static
  445.     {
  446.         if (!$this->visits->contains($visit)) {
  447.             $this->visits->add($visit);
  448.             $visit->setStore($this);
  449.         }
  451.         return $this;
  452.     }
  454.     public function removeVisit(Visit $visit): static
  455.     {
  456.         if ($this->visits->removeElement($visit)) {
  457.             // set the owning side to null (unless already changed)
  458.             if ($visit->getStore() === $this) {
  459.                 $visit->setStore(null);
  460.             }
  461.         }
  463.         return $this;
  464.     }
  465. }