src/Flexy/ShopBundle/Entity/Shipping/ShippingMethod.php line 27

  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\Customer\CustomerGroup;
  8. use App\Flexy\ShopBundle\Entity\Product\Product;
  9. use App\Flexy\ShopBundle\Entity\Taxes\ShippingTax;
  10. use App\Flexy\ShopBundle\Entity\Taxes\ValueAddedTax;
  11. use App\Repository\Flexy\ShopBundle\Entity\Shipping\ShippingRepository;
  12. use Doctrine\Common\Collections\ArrayCollection;
  13. use Doctrine\Common\Collections\Collection;
  14. use App\Flexy\ShopBundle\Entity\Shipping\Vehicle\ShippingVehicleType;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use Symfony\Component\Validator\Constraints as Assert;
  17. use Gedmo\Mapping\Annotation as Gedmo;
  18. use Gedmo\SoftDeleteable\Traits\SoftDeleteableEntity;
  19. use Symfony\Component\Serializer\Annotation\Groups;
  21. #[ApiResource(
  22.     normalizationContext: ['groups' => ['read']],
  23.     denormalizationContext: ['groups' => ['write']],
  24. )]
  25. #[ORM\Entity(repositoryClass: ShippingRepository::class)]
  26. #[Gedmo\SoftDeleteable(fieldName: 'deletedAt', timeAware: false, hardDelete: true)]
  27. class ShippingMethod implements \Stringable
  28. {
  30.     use SoftDeleteableEntity;
  32.     
  33.     #[ORM\Id]
  34.     #[ORM\GeneratedValue]
  35.     #[ORM\Column(type: 'integer')]
  36.     #[Groups(["read"])]
  37.     private $id;
  39.     #[ORM\Column(type: 'string', length: 255)]
  40.     #[Groups(["write","read"])]
  41.     private ?string $name = null;
  42.     #[Groups(["write","read"])]
  43.     #[ORM\Column(type: 'text', nullable: true)]
  44.     private ?string $description = null;
  46.     /**
  47.      * @example If not precised use the sluggable value of the name
  48.      */
  50.     #[ORM\Column(type: 'string', length: 255)]
  51.     private string $code = "SHIP001";
  53.     #[ORM\Column(type: 'boolean', nullable: true)]
  54.     private ?bool $isEnabled = null;
  56.     #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  57.     private ?\DateTimeImmutable $createdAt = null;
  59.     #[ORM\OneToMany(targetEntity: Shipment::class, mappedBy: 'method')]
  60.     private \Doctrine\Common\Collections\Collection|array $shippments;
  62.     #[Groups(["write","read"])]
  63.     #[ORM\Column(type: 'integer', nullable: true)]
  64.     private ?int $processingDuration = null;
  66.     #[Groups(["write","read"])]
  67.     #[ORM\Column(type: 'float', nullable: true)]
  68.     private ?float $preparationDuration = null;
  70.     #[Groups(["write","read"])]
  71.     #[ORM\Column(type: 'float', nullable: true)]
  72.     private ?float $shippingDuration = null;
  74.     /**
  75.      *
  76.      * @example standard price or default price
  77.      */
  78.     #[ORM\Column(type: 'float', nullable: true)]
  79.     private ?float $price = null;
  83.     /**
  84.      *
  85.      * @example Rules or conditions for shipping
  86.      */
  87.     #[ORM\OneToMany(targetEntity: ShippingRule::class, mappedBy: 'shippingMethod', cascade: ['persist', 'remove'])]
  88.     #[Assert\Valid()]
  89.     private \Doctrine\Common\Collections\Collection|array $shippingRules;
  91.     #[ORM\OneToMany(targetEntity: Order::class, mappedBy: 'shippingMethod')]
  92.     private \Doctrine\Common\Collections\Collection|array $orders;
  94.     #[ORM\ManyToMany(targetEntity: CityRegion::class, inversedBy: 'shippingMethods')]
  95.     private \Doctrine\Common\Collections\Collection|array $cityRegions;
  98.     #[ORM\ManyToOne(targetEntity: ShippingVehicleType::class, inversedBy: 'shippingMethods')]
  99.     #[ORM\JoinColumn(nullable: true)]
  100.     private $shippingVehicleType;
  103.    #[ORM\ManyToOne(targetEntity: CustomerGroup::class, inversedBy: 'shippingMethods')]
  104.     #[ORM\JoinColumn(nullable: true)]
  105.     private $customerGroup;
  107.    #[ORM\Column(nullable: true)]
  108.    private ?bool $isSeparatelyCalculated = null;
  110.    #[ORM\Column(nullable: true)]
  111.    private array $calculationMethod = [];
  113.    #[ORM\ManyToOne]
  114.    private ?ValueAddedTax $taxVAT = null;
  116.    #[ORM\ManyToOne]
  117.    private ?ShippingTax $shippingTax = null;
  119.    #[ORM\Column(nullable: true)]
  120.    private ?float $declaredValueTax = null;
  122.    #[ORM\Column(nullable: true)]
  123.    private ?float $papersFees = null;
  125.    #[ORM\Column(nullable: true)]
  126.    private ?float $codCashFees = null;
  128.    #[ORM\Column(nullable: true)]
  129.    private ?float $codCheckOrBillFees = null;
  131.     /**
  132.      *
  133.      * @example Type or style of calculation can be applied (one or more)
  134.      */
  135.    #[ORM\OneToMany(mappedBy: 'shippingMethod', targetEntity: ShippingCalculationMethod::class,cascade:["persist","remove"])]
  136.    private Collection $calculationMethods;
  138.    #[ORM\Column(nullable: true)]
  139.    private ?bool $isTaxesIncludedInPrice = null;
  143.    #[ORM\ManyToMany(targetEntity: Product::class, mappedBy: 'includedShippingMethods')]
  144.    private Collection $products;
  146.    #[ORM\ManyToMany(targetEntity: Country::class, inversedBy: 'shippingMethods')]
  147.    private Collection $countries;
  154.     public function __toString(): string
  155.     {
  156.         return (string) $this->name;
  157.     }
  158.     public function __construct()
  159.     {
  160.         $this->shippments = new ArrayCollection();
  161.         $this->shippingRules = new ArrayCollection();
  162.         $this->orders = new ArrayCollection();
  163.         $this->cityRegions = new ArrayCollection();
  164.         $this->calculationMethods = new ArrayCollection();
  165.         $this->products = new ArrayCollection();
  166.         $this->countries = new ArrayCollection();
  167.     }
  169.     public function getId(): ?int
  170.     {
  171.         return $this->id;
  172.     }
  174.     public function getName(): ?string
  175.     {
  176.         return $this->name;
  177.     }
  179.     public function setName(string $name): self
  180.     {
  181.         $this->name = $name;
  183.         return $this;
  184.     }
  186.     public function getDescription(): ?string
  187.     {
  188.         return $this->description;
  189.     }
  191.     public function setDescription(?string $description): self
  192.     {
  193.         $this->description = $description;
  195.         return $this;
  196.     }
  198.     public function getCode(): ?string
  199.     {
  200.         return $this->code;
  201.     }
  203.     public function setCode(string $code): self
  204.     {
  205.         $this->code = $code;
  207.         return $this;
  208.     }
  210.     public function getIsEnabled(): ?bool
  211.     {
  212.         return $this->isEnabled;
  213.     }
  215.     public function setIsEnabled(?bool $isEnabled): self
  216.     {
  217.         $this->isEnabled = $isEnabled;
  219.         return $this;
  220.     }
  222.     public function getCreatedAt(): ?\DateTimeImmutable
  223.     {
  224.         return $this->createdAt;
  225.     }
  227.     public function setCreatedAt(?\DateTimeImmutable $createdAt): self
  228.     {
  229.         $this->createdAt = $createdAt;
  231.         return $this;
  232.     }
  234.     /**
  235.      * @return Collection|Shipment[]
  236.      */
  237.     public function getShipments(): Collection
  238.     {
  239.         return $this->shippments;
  240.     }
  242.     public function addShipment(Shipment $shippment): self
  243.     {
  244.         if (!$this->shippments->contains($shippment)) {
  245.             $this->shippments[] = $shippment;
  246.             $shippment->setMethod($this);
  247.         }
  249.         return $this;
  250.     }
  252.     public function removeShipment(Shipment $shippment): self
  253.     {
  254.         if ($this->shippments->removeElement($shippment)) {
  255.             // set the owning side to null (unless already changed)
  256.             if ($shippment->getMethod() === $this) {
  257.                 $shippment->setMethod(null);
  258.             }
  259.         }
  261.         return $this;
  262.     }
  264.     public function getProcessingDuration(): ?int
  265.     {
  266.         return $this->processingDuration;
  267.     }
  269.     public function setProcessingDuration(?int $processingDuration): self
  270.     {
  271.         $this->processingDuration = $processingDuration;
  273.         return $this;
  274.     }
  276.     public function getPreparationDuration(): ?float
  277.     {
  278.         return $this->preparationDuration;
  279.     }
  281.     public function setPreparationDuration(?float $preparationDuration): self
  282.     {
  283.         $this->preparationDuration = $preparationDuration;
  285.         return $this;
  286.     }
  288.     public function getShippingDuration(): ?float
  289.     {
  290.         return $this->shippingDuration;
  291.     }
  293.     public function setShippingDuration(?float $shippingDuration): self
  294.     {
  295.         $this->shippingDuration = $shippingDuration;
  297.         return $this;
  298.     }
  300.     public function getPrice(): ?float
  301.     {
  302.         return $this->price;
  303.     }
  305.     public function setPrice(?float $price): self
  306.     {
  307.         $this->price = $price;
  309.         return $this;
  310.     }
  312.     /**
  313.      * @return Collection<int, ShippingRule>
  314.      */
  315.     public function getShippingRules(): Collection
  316.     {
  317.         return $this->shippingRules;
  318.     }
  320.     public function addShippingRule(ShippingRule $shippingRule): self
  321.     {
  322.         if (!$this->shippingRules->contains($shippingRule)) {
  323.             $this->shippingRules[] = $shippingRule;
  324.             $shippingRule->setShippingMethod($this);
  325.         }
  327.         return $this;
  328.     }
  330.     public function removeShippingRule(ShippingRule $shippingRule): self
  331.     {
  332.         if ($this->shippingRules->removeElement($shippingRule)) {
  333.             // set the owning side to null (unless already changed)
  334.             if ($shippingRule->getShippingMethod() === $this) {
  335.                 $shippingRule->setShippingMethod(null);
  336.             }
  337.         }
  339.         return $this;
  340.     }
  342.     /**
  343.      * @return Collection<int, Order>
  344.      */
  345.     public function getOrders(): Collection
  346.     {
  347.         return $this->orders;
  348.     }
  350.     public function addOrder(Order $order): self
  351.     {
  352.         if (!$this->orders->contains($order)) {
  353.             $this->orders[] = $order;
  354.             $order->setShippingMethod($this);
  355.         }
  357.         return $this;
  358.     }
  360.     public function removeOrder(Order $order): self
  361.     {
  362.         if ($this->orders->removeElement($order)) {
  363.             // set the owning side to null (unless already changed)
  364.             if ($order->getShippingMethod() === $this) {
  365.                 $order->setShippingMethod(null);
  366.             }
  367.         }
  369.         return $this;
  370.     }
  372.     /**
  373.      * @return Collection<int, CityRegion>
  374.      */
  375.     public function getCityRegions(): Collection
  376.     {
  377.         return $this->cityRegions;
  378.     }
  380.     public function addCityRegion(CityRegion $cityRegion): self
  381.     {
  382.         if (!$this->cityRegions->contains($cityRegion)) {
  383.             $this->cityRegions[] = $cityRegion;
  384.             $cityRegion->addShippingMethod($this);
  385.         }
  387.         return $this;
  388.     }
  390.     public function removeCityRegion(CityRegion $cityRegion): self
  391.     {
  392.         if ($this->cityRegions->removeElement($cityRegion)) {
  393.             $cityRegion->removeShippingMethod($this);
  394.         }
  396.         return $this;
  397.     }
  401.     /**
  402.      * Get the value of shippingVehicleType
  403.      */ 
  404.     public function getShippingVehicleType()
  405.     {
  406.         return $this->shippingVehicleType;
  407.     }
  409.     /**
  410.      * Set the value of shippingVehicleType
  411.      *
  412.      * @return  self
  413.      */ 
  414.     public function setShippingVehicleType($shippingVehicleType)
  415.     {
  416.         $this->shippingVehicleType = $shippingVehicleType;
  418.         return $this;
  419.     }
  421.     /**
  422.      * Get the value of customerGroup
  423.      */ 
  424.     public function getCustomerGroup()
  425.     {
  426.         return $this->customerGroup;
  427.     }
  429.     /**
  430.      * Set the value of customerGroup
  431.      *
  432.      * @return  self
  433.      */ 
  434.     public function setCustomerGroup($customerGroup)
  435.     {
  436.         $this->customerGroup = $customerGroup;
  438.         return $this;
  439.     }
  441.     public function isIsSeparatelyCalculated(): ?bool
  442.     {
  443.         return $this->isSeparatelyCalculated;
  444.     }
  446.     public function setIsSeparatelyCalculated(?bool $isSeparatelyCalculated): self
  447.     {
  448.         $this->isSeparatelyCalculated = $isSeparatelyCalculated;
  450.         return $this;
  451.     }
  453.     public function getCalculationMethod(): array
  454.     {
  455.         return $this->calculationMethod;
  456.     }
  458.     public function setCalculationMethod(?array $calculationMethod): self
  459.     {
  460.         $this->calculationMethod = $calculationMethod;
  462.         return $this;
  463.     }
  465.     public function getTaxVAT(): ?ValueAddedTax
  466.     {
  467.         return $this->taxVAT;
  468.     }
  470.     public function setTaxVAT(?ValueAddedTax $taxVAT): self
  471.     {
  472.         $this->taxVAT = $taxVAT;
  474.         return $this;
  475.     }
  477.     public function getShippingTax(): ?ShippingTax
  478.     {
  479.         return $this->shippingTax;
  480.     }
  482.     public function setShippingTax(?ShippingTax $shippingTax): self
  483.     {
  484.         $this->shippingTax = $shippingTax;
  486.         return $this;
  487.     }
  489.     public function getDeclaredValueTax(): ?float
  490.     {
  491.         return $this->declaredValueTax;
  492.     }
  494.     public function setDeclaredValueTax(?float $declaredValueTax): self
  495.     {
  496.         $this->declaredValueTax = $declaredValueTax;
  498.         return $this;
  499.     }
  501.     public function getPapersFees(): ?float
  502.     {
  503.         return $this->papersFees;
  504.     }
  506.     public function setPapersFees(?float $papersFees): self
  507.     {
  508.         $this->papersFees = $papersFees;
  510.         return $this;
  511.     }
  513.     public function getCodCashFees(): ?float
  514.     {
  515.         return $this->codCashFees;
  516.     }
  518.     public function setCodCashFees(?float $codCashFees): self
  519.     {
  520.         $this->codCashFees = $codCashFees;
  522.         return $this;
  523.     }
  525.     public function getCodCheckOrBillFees(): ?float
  526.     {
  527.         return $this->codCheckOrBillFees;
  528.     }
  530.     public function setCodCheckOrBillFees(?float $codCheckOrBillFees): self
  531.     {
  532.         $this->codCheckOrBillFees = $codCheckOrBillFees;
  534.         return $this;
  535.     }
  537.     /**
  538.      * @return Collection<int, ShippingCalculationMethod>
  539.      */
  540.     public function getCalculationMethods(): Collection
  541.     {
  542.         return $this->calculationMethods;
  543.     }
  545.     public function addCalculationMethod(ShippingCalculationMethod $calculationMethod): self
  546.     {
  547.         if (!$this->calculationMethods->contains($calculationMethod)) {
  548.             $this->calculationMethods->add($calculationMethod);
  549.             $calculationMethod->setShippingMethod($this);
  550.         }
  552.         return $this;
  553.     }
  555.     public function removeCalculationMethod(ShippingCalculationMethod $calculationMethod): self
  556.     {
  557.         if ($this->calculationMethods->removeElement($calculationMethod)) {
  558.             // set the owning side to null (unless already changed)
  559.             if ($calculationMethod->getShippingMethod() === $this) {
  560.                 $calculationMethod->setShippingMethod(null);
  561.             }
  562.         }
  564.         return $this;
  565.     }
  567.     public function isIsTaxesIncludedInPrice(): ?bool
  568.     {
  569.         return $this->isTaxesIncludedInPrice;
  570.     }
  572.     public function setIsTaxesIncludedInPrice(?bool $isTaxesIncludedInPrice): self
  573.     {
  574.         $this->isTaxesIncludedInPrice = $isTaxesIncludedInPrice;
  576.         return $this;
  577.     }
  581.     /**
  582.      * @return Collection<int, Product>
  583.      */
  584.     public function getProducts(): Collection
  585.     {
  586.         return $this->products;
  587.     }
  589.     public function addProduct(Product $product): static
  590.     {
  591.         if (!$this->products->contains($product)) {
  592.             $this->products->add($product);
  593.             $product->addIncludedShippingMethod($this);
  594.         }
  596.         return $this;
  597.     }
  599.     public function removeProduct(Product $product): static
  600.     {
  601.         if ($this->products->removeElement($product)) {
  602.             $product->removeIncludedShippingMethod($this);
  603.         }
  605.         return $this;
  606.     }
  608.     /**
  609.      * @return Collection<int, Country>
  610.      */
  611.     public function getCountries(): Collection
  612.     {
  613.         return $this->countries;
  614.     }
  616.     public function addCountry(Country $country): static
  617.     {
  618.         if (!$this->countries->contains($country)) {
  619.             $this->countries->add($country);
  620.             $country->addShippingMethod($this);
  621.         }
  623.         return $this;
  624.     }
  626.     public function removeCountry(Country $country): static
  627.     {
  628.         if ($this->countries->removeElement($country)) {
  629.             $country->removeShippingMethod($this);
  630.         }
  632.         return $this;
  633.     }
  636. }