src/Flexy/ShopBundle/Entity/Shipping/CityRegion.php line 21

  1. <?php
  3. namespace App\Flexy\ShopBundle\Entity\Shipping;
  5. use ApiPlatform\Core\Annotation\ApiResource;
  6. use App\Flexy\ShopBundle\Entity\Order\Order;
  7. use App\Flexy\ShopBundle\Entity\Store\Store;
  8. use App\Flexy\ShopBundle\Entity\Vendor\Vendor;
  9. use App\Flexy\ShopBundle\Repository\Shipping\CityRegionRepository;
  10. use Doctrine\Common\Collections\ArrayCollection;
  11. use Doctrine\Common\Collections\Collection;
  12. use Doctrine\ORM\Mapping as ORM;
  13. use Symfony\Component\Serializer\Annotation\Groups;
  15. #[ApiResource(
  16.     normalizationContext: ['groups' => ['read']],
  17.     denormalizationContext: ['groups' => ['write']],
  18. )]
  19. //#[ApiFilter(SearchFilter::class, properties: ['user.googleId' => 'exact','user.facebookId' => 'exact'])]
  20. #[ORM\Entity(repositoryClass: CityRegionRepository::class)]
  21. class CityRegion implements \Stringable
  22. {
  23.     #[ORM\Id]
  24.     #[ORM\GeneratedValue]
  25.     #[ORM\Column(type: 'integer')]
  26.     #[Groups(["read","write"])]
  27.     private $id;
  29.     #[ORM\Column(type: 'string', length: 255)]
  30.     #[Groups(["read","write"])]
  31.     private ?string $name = null;
  33.     #[ORM\Column(type: 'text', nullable: true)]
  34.     #[Groups(["read","write"])]
  35.     private ?string $description = null;
  37.     #[ORM\Column(type: 'boolean', nullable: true)]
  38.     private $isDefault;
  39.     
  40.     #[ORM\Column(type: 'boolean', nullable: true)]
  41.     private $isActive;
  43.     #[ORM\ManyToOne(targetEntity: City::class, inversedBy: 'regions')]
  44.     private ?\App\Flexy\ShopBundle\Entity\Shipping\City $city = null;
  46.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  47.     private ?string $color = null;
  49.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  50.     private $type;
  52.         #[ORM\Column(type: 'string', length: 255, nullable: true)]
  53.     private $zipCode;
  55.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  56.     private $regionCode;
  58.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  59.     #[Groups(["read","write"])]
  60.     private $lng;
  62.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  63.     #[Groups(["read","write"])]
  64.     private $lat;
  66.     #[ORM\ManyToMany(targetEntity: ShippingMethod::class, mappedBy: 'cityRegions')]
  67.     private \Doctrine\Common\Collections\Collection|array $shippingMethods;
  69.     #[ORM\ManyToOne(targetEntity: Vendor::class)]
  70.     private $vendor;
  72.     #[ORM\OneToMany(targetEntity: Order::class, mappedBy: 'cityRegion')]
  73.     private \Doctrine\Common\Collections\Collection|array $orders;
  75.         #[ORM\OneToMany(targetEntity: Order::class, mappedBy: 'cityRegionCollect')]
  76.     private \Doctrine\Common\Collections\Collection|array $collectedOrders ;
  79.     #[ORM\OneToMany(targetEntity: ShipmentItem::class, mappedBy: 'shippingCityRegion')]
  80.     private \Doctrine\Common\Collections\Collection|array $shipmentItemsShipped;
  82.      #[ORM\OneToMany(targetEntity: ShipmentItem::class, mappedBy: 'collectCityRegion')]
  83.     private \Doctrine\Common\Collections\Collection|array $shipmentItemsCollected ;
  85.      #[ORM\OneToMany(mappedBy: '�cityRegion', targetEntity: Store::class)]
  86.      private Collection $stores;
  88.      #[ORM\OneToMany(mappedBy: 'collectCityRegion', targetEntity: Shipment::class,cascade:["remove"])]
  89.      #[ORM\JoinColumn(name: "collect_city_region_id", referencedColumnName: "id", onDelete: "SET NULL")]
  90.      private Collection $collectedShipments;
  92.      #[ORM\OneToMany(mappedBy: 'shippingCityRegion', targetEntity: Shipment::class,cascade:["remove"])]
  93.      #[ORM\JoinColumn(name: "shipping_city_region_id", referencedColumnName: "id", onDelete: "SET NULL")]
  94.      private Collection $shippedShipments;
  96.     
  97.     
  99.     public function __construct()
  100.     {
  101.         $this->shippingMethods = new ArrayCollection();
  102.         $this->orders = new ArrayCollection();
  103.         $this->stores = new ArrayCollection();
  104.         $this->collectedShipments = new ArrayCollection();
  105.         $this->shippedShipments = new ArrayCollection();
  106.     }
  108.     public function __toString(): string
  109.     {
  110.         return (string)$this->name;
  111.     }
  113.     public function getId(): ?int
  114.     {
  115.         return $this->id;
  116.     }
  118.     public function getName(): ?string
  119.     {
  120.         return $this->name;
  121.     }
  123.     public function setName(string $name): self
  124.     {
  125.         $this->name = $name;
  127.         return $this;
  128.     }
  130.     public function getDescription(): ?string
  131.     {
  132.         return $this->description;
  133.     }
  135.     public function setDescription(?string $description): self
  136.     {
  137.         $this->description = $description;
  139.         return $this;
  140.     }
  142.     public function getCity(): ?City
  143.     {
  144.         return $this->city;
  145.     }
  147.     public function setCity(?City $city): self
  148.     {
  149.         $this->city = $city;
  151.         return $this;
  152.     }
  154.     public function getColor(): ?string
  155.     {
  156.         return $this->color;
  157.     }
  159.     public function setColor(?string $color): self
  160.     {
  161.         $this->color = $color;
  163.         return $this;
  164.     }
  166.     /**
  167.      * @return Collection<int, ShippingMethod>
  168.      */
  169.     public function getShippingMethods(): Collection
  170.     {
  171.         return $this->shippingMethods;
  172.     }
  174.     public function addShippingMethod(ShippingMethod $shippingMethod): self
  175.     {
  176.         if (!$this->shippingMethods->contains($shippingMethod)) {
  177.             $this->shippingMethods[] = $shippingMethod;
  178.         }
  180.         return $this;
  181.     }
  183.     public function removeShippingMethod(ShippingMethod $shippingMethod): self
  184.     {
  185.         $this->shippingMethods->removeElement($shippingMethod);
  187.         return $this;
  188.     }
  190.     /**
  191.      * @return Collection<int, Order>
  192.      */
  193.     public function getOrders(): Collection
  194.     {
  195.         return $this->orders;
  196.     }
  198.     public function addOrder(Order $order): self
  199.     {
  200.         if (!$this->orders->contains($order)) {
  201.             $this->orders[] = $order;
  202.             $order->setCityRegionCollect($this);
  203.         }
  205.         return $this;
  206.     }
  208.     public function removeOrder(Order $order): self
  209.     {
  210.         if ($this->orders->removeElement($order)) {
  211.             // set the owning side to null (unless already changed)
  212.             if ($order->getCityRegionCollect() === $this) {
  213.                 $order->setCityRegionCollect(null);
  214.             }
  215.         }
  217.         return $this;
  218.     }
  222.         /**
  223.      * @return Collection<int, Order>
  224.      */
  225.     public function getCollectedOrders(): Collection
  226.     {
  227.         return $this->collectedOrders;
  228.     }
  230.     public function addCollectedOrder(Order $collectedOrder): self
  231.     {
  232.         if (!$this->collectedOrders->contains($collectedOrder)) {
  233.             $this->collectedOrders[] = $collectedOrder;
  234.             $collectedOrder->setCityRegionCollect($this);
  235.         }
  237.         return $this;
  238.     }
  240.     public function removeCollectedOrder(Order $collectedOrder): self
  241.     {
  242.         if ($this->collectedOrders->removeElement($collectedOrder)) {
  243.             // set the owning side to null (unless already changed)
  244.             if ($collectedOrder->getCityRegionCollect() === $this) {
  245.                 $collectedOrder->setCityRegionCollect(null);
  246.             }
  247.         }
  249.         return $this;
  250.     }
  253.                 /**
  254.      * @return Collection<int, ShipmentItem>
  255.      */
  256.     public function getShipmentItemsCollected(): Collection
  257.     {
  258.         return $this->shipmentItemsCollected;
  259.     }
  261.     public function addShipmentItemCollected(ShipmentItem $shipmentItemCollected): self
  262.     {
  263.         if (!$this->shipmentItemsCollected->contains($shipmentItemCollected)) {
  264.             $this->shipmentItemsCollected[] = $shipmentItemCollected;
  265.             $shipmentItemCollected->setCollectCityRegion($this);
  266.         }
  268.         return $this;
  269.     }
  271.     public function removeShipmentItemCollected(ShipmentItem $shipmentItemCollected): self
  272.     {
  273.         if ($this->shipmentItemsCollected->removeElement($shipmentItemCollected)) {
  274.             // set the owning side to null (unless already changed)
  275.             if ($shipmentItemCollected->getCollectCityRegion() === $this) {
  276.                 $shipmentItemCollected->setCollectCityRegion(null);
  277.             }
  278.         }
  280.         return $this;
  281.     }
  283.             /**
  284.      * @return Collection<int, ShipmentItem>
  285.      */
  286.     public function getShipmentItemsShipped(): Collection
  287.     {
  288.         return $this->shipmentItemsShipped;
  289.     }
  291.     public function addShipmentItemShipped(ShipmentItem $shipmentItemShipped): self
  292.     {
  293.         if (!$this->shipmentItemsShipped->contains($shipmentItemShipped)) {
  294.             $this->shipmentItemsShipped[] = $shipmentItemShipped;
  295.             $shipmentItemShipped->setShippingCityRegion($this);
  296.         }
  298.         return $this;
  299.     }
  301.     public function removeShipmentItemShipped(ShipmentItem $shipmentItemShipped): self
  302.     {
  303.         if ($this->shipmentItemsShipped->removeElement($shipmentItemShipped)) {
  304.             // set the owning side to null (unless already changed)
  305.             if ($shipmentItemShipped->getShippingCityRegion() === $this) {
  306.                 $shipmentItemShipped->setShippingCityRegion(null);
  307.             }
  308.         }
  310.         return $this;
  311.     }
  313.     /**
  314.      * Get the value of lng
  315.      */ 
  316.     public function getLng()
  317.     {
  318.         return $this->lng;
  319.     }
  321.     /**
  322.      * Set the value of lng
  323.      *
  324.      * @return  self
  325.      */ 
  326.     public function setLng($lng)
  327.     {
  328.         $this->lng = $lng;
  330.         return $this;
  331.     }
  333.     /**
  334.      * Get the value of lat
  335.      */ 
  336.     public function getLat()
  337.     {
  338.         return $this->lat;
  339.     }
  341.     /**
  342.      * Set the value of lat
  343.      *
  344.      * @return  self
  345.      */ 
  346.     public function setLat($lat)
  347.     {
  348.         $this->lat = $lat;
  350.         return $this;
  351.     }
  353.     /**
  354.      * Get the value of type
  355.      */ 
  356.     public function getType()
  357.     {
  358.         return $this->type;
  359.     }
  361.     /**
  362.      * Set the value of type
  363.      *
  364.      * @return  self
  365.      */ 
  366.     public function setType($type)
  367.     {
  368.         $this->type = $type;
  370.         return $this;
  371.     }
  373.     /**
  374.      * Get the value of zipCode
  375.      */ 
  376.     public function getZipCode()
  377.     {
  378.         return $this->zipCode;
  379.     }
  381.     /**
  382.      * Set the value of zipCode
  383.      *
  384.      * @return  self
  385.      */ 
  386.     public function setZipCode($zipCode)
  387.     {
  388.         $this->zipCode = $zipCode;
  390.         return $this;
  391.     }
  393.     /**
  394.      * Get the value of regionCode
  395.      */ 
  396.     public function getRegionCode()
  397.     {
  398.         return $this->regionCode;
  399.     }
  401.     /**
  402.      * Set the value of regionCode
  403.      *
  404.      * @return  self
  405.      */ 
  406.     public function setRegionCode($regionCode)
  407.     {
  408.         $this->regionCode = $regionCode;
  410.         return $this;
  411.     }
  413.     /**
  414.      * Get the value of vendor
  415.      */ 
  416.     public function getVendor()
  417.     {
  418.         return $this->vendor;
  419.     }
  421.     /**
  422.      * Set the value of vendor
  423.      *
  424.      * @return  self
  425.      */ 
  426.     public function setVendor($vendor)
  427.     {
  428.         $this->vendor = $vendor;
  430.         return $this;
  431.     }
  433.     /**
  434.      * Get the value of isDefault
  435.      */ 
  436.     public function getIsDefault()
  437.     {
  438.         return $this->isDefault;
  439.     }
  441.     /**
  442.      * Set the value of isDefault
  443.      *
  444.      * @return  self
  445.      */ 
  446.     public function setIsDefault($isDefault)
  447.     {
  448.         $this->isDefault = $isDefault;
  450.         return $this;
  451.     }
  453.     /**
  454.      * Get the value of isActive
  455.      */ 
  456.     public function getIsActive()
  457.     {
  458.         return $this->isActive;
  459.     }
  461.     /**
  462.      * Set the value of isActive
  463.      *
  464.      * @return  self
  465.      */ 
  466.     public function setIsActive($isActive)
  467.     {
  468.         $this->isActive = $isActive;
  470.         return $this;
  471.     }
  473.     /**
  474.      * @return Collection<int, Store>
  475.      */
  476.     public function getStores(): Collection
  477.     {
  478.         return $this->stores;
  479.     }
  481.     public function addStore(Store $store): self
  482.     {
  483.         if (!$this->stores->contains($store)) {
  484.             $this->stores->add($store);
  485.             $store->set�cityRegion($this);
  486.         }
  488.         return $this;
  489.     }
  491.     public function removeStore(Store $store): self
  492.     {
  493.         if ($this->stores->removeElement($store)) {
  494.             // set the owning side to null (unless already changed)
  495.             if ($store->get�cityRegion() === $this) {
  496.                 $store->set�cityRegion(null);
  497.             }
  498.         }
  500.         return $this;
  501.     }
  503.     /**
  504.      * @return Collection<int, Shipment>
  505.      */
  506.     public function getCollectedShipments(): Collection
  507.     {
  508.         return $this->collectedShipments;
  509.     }
  511.     public function addCollectedShipment(Shipment $collectedShipment): self
  512.     {
  513.         if (!$this->collectedShipments->contains($collectedShipment)) {
  514.             $this->collectedShipments->add($collectedShipment);
  515.             $collectedShipment->setCollectCityRegion($this);
  516.         }
  518.         return $this;
  519.     }
  521.     public function removeCollectedShipment(Shipment $collectedShipment): self
  522.     {
  523.         if ($this->collectedShipments->removeElement($collectedShipment)) {
  524.             // set the owning side to null (unless already changed)
  525.             if ($collectedShipment->getCollectCityRegion() === $this) {
  526.                 $collectedShipment->setCollectCityRegion(null);
  527.             }
  528.         }
  530.         return $this;
  531.     }
  533.     /**
  534.      * @return Collection<int, Shipment>
  535.      */
  536.     public function getShippedShipments(): Collection
  537.     {
  538.         return $this->shippedShipments;
  539.     }
  541.     public function addShippedShipment(Shipment $shippedShipment): self
  542.     {
  543.         if (!$this->shippedShipments->contains($shippedShipment)) {
  544.             $this->shippedShipments->add($shippedShipment);
  545.             $shippedShipment->setShippingCityRegion($this);
  546.         }
  548.         return $this;
  549.     }
  551.     public function removeShippedShipment(Shipment $shippedShipment): self
  552.     {
  553.         if ($this->shippedShipments->removeElement($shippedShipment)) {
  554.             // set the owning side to null (unless already changed)
  555.             if ($shippedShipment->getShippingCityRegion() === $this) {
  556.                 $shippedShipment->setShippingCityRegion(null);
  557.             }
  558.         }
  560.         return $this;
  561.     }
  562. }