src/Entity/Products.php line 18

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ProductsRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Doctrine\ORM\Mapping\InverseJoinColumn;
  10. use Doctrine\ORM\Mapping\JoinColumn;
  11. use Doctrine\ORM\Mapping\JoinTable;
  13. #[ORM\Table(name: 'products')]
  14. #[ORM\Index(name: 'name', columns: ['name'], flags: ['fulltext'])]
  15. #[ORM\Index(name: 'active_ingredient', columns: ['active_ingredient'], flags: ['fulltext'])]
  16. #[ORM\Index(name: 'description', columns: ['description'], flags: ['fulltext'])]
  17. #[ORM\Entity(repositoryClass: ProductsRepository::class)]
  18. class Products
  19. {
  20.     #[ORM\Id]
  21.     #[ORM\GeneratedValue]
  22.     #[ORM\Column(type: 'integer')]
  23.     private $id;
  25.     #[ORM\ManyToOne(targetEntity: SubCategories::class, inversedBy: 'products')]
  26.     private $subCategory;
  28.     #[ORM\Column(type: 'boolean')]
  29.     private $isPublished;
  31.     #[ORM\Column(type: 'string', length: 255)]
  32.     private $name;
  34.     #[ORM\Column(type: 'string', length: 255)]
  35.     private $activeIngredient;
  37.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  38.     private $image;
  40.     #[ORM\Column(type: 'text', nullable: true)]
  41.     private $description;
  43.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  44.     private $dosage;
  46.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  47.     private $size;
  49.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  50.     private $form;
  52.     #[ORM\Column(type: 'string', length: 255)]
  53.     private $unit;
  55.     #[ORM\Column(type: 'float')]
  56.     private $unitPrice;
  58.     #[ORM\Column(type: 'integer')]
  59.     private $stockCount;
  61.     #[ORM\Column(type: 'datetime')]
  62.     private $modified;
  64.     #[ORM\Column(type: 'datetime')]
  65.     private $created;
  67.     #[ORM\OneToMany(targetEntity: DistributorProducts::class, mappedBy: 'product')]
  68.     private $distributorProducts;
  70.     #[ORM\OneToMany(targetEntity: OrderItems::class, mappedBy: 'product')]
  71.     private $orderItems;
  73.     #[ORM\OneToMany(targetEntity: ProductNotes::class, mappedBy: 'product')]
  74.     private $productNotes;
  76.     #[ORM\OneToMany(targetEntity: ProductReviews::class, mappedBy: 'product')]
  77.     private $productReviews;
  79.     #[ORM\OneToMany(targetEntity: AvailabilityTracker::class, mappedBy: 'product')]
  80.     private $availabilityTrackers;
  82.     #[ORM\OneToMany(targetEntity: ListItems::class, mappedBy: 'product')]
  83.     private $listItems;
  85.     #[ORM\OneToMany(targetEntity: BasketItems::class, mappedBy: 'product')]
  86.     private $basketItems;
  88.     #[ORM\OneToMany(targetEntity: ClinicProducts::class, mappedBy: 'product')]
  89.     private $clinicProducts;
  91.     #[ORM\OneToMany(targetEntity: ProductFavourites::class, mappedBy: 'product')]
  92.     private $productFavourites;
  94.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  95.     private $sku;
  97.     #[ORM\OneToMany(targetEntity: ProductManufacturers::class, mappedBy: 'products')]
  98.     private $productManufacturers;
  100.     #[ORM\OneToMany(targetEntity: ProductImages::class, mappedBy: 'product')]
  101.     private $productImages;
  103.     #[ORM\Column(type: 'boolean')]
  104.     private $expiryDateRequired;
  106.     #[ORM\OneToMany(targetEntity: ProductsSpecies::class, mappedBy: 'products')]
  107.     private $productsSpecies;
  109.     #[ORM\ManyToOne(targetEntity: Categories2::class, inversedBy: 'products')]
  110.     private $category2;
  112.     #[ORM\ManyToOne(targetEntity: Categories3::class, inversedBy: 'products')]
  113.     private $category3;
  115.     #[ORM\Column(type: 'json', nullable: true)]
  116.     private $tags = [];
  118.     #[ORM\Column(type: 'text', nullable: true)]
  119.     private $slug;
  121.     #[ORM\ManyToOne(targetEntity: Categories1::class, inversedBy: 'products')]
  122.     private $category;
  124.     #[ORM\Column(type: 'boolean')]
  125.     private $isActive;
  127.     #[ORM\Column(type: 'float', nullable: true)]
  128.     private $priceFrom;
  130.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  131.     private $dosageUnit;
  133.     #[ORM\Column(type: 'json', nullable: true)]
  134.     private $manufacturerIds = [];
  136.     #[ORM\OneToMany(targetEntity: ProductRetail::class, mappedBy: 'product')]
  137.     private $productRetails;
  139.     #[ORM\Column(type: 'boolean', nullable: true)]
  140.     private $isControlled;
  142.     public function __construct()
  143.     {
  144.         $this->setCreated(new \DateTime());
  145.         if ($this->getModified() == null) {
  146.             $this->setModified(new \DateTime());
  147.         }
  149.         $this->distributorProducts = new ArrayCollection();
  150.         $this->orderItems = new ArrayCollection();
  151.         $this->productNotes = new ArrayCollection();
  152.         $this->productReviews = new ArrayCollection();
  153.         $this->availabilityTrackers = new ArrayCollection();
  154.         $this->productsSpecies = new ArrayCollection();
  155.         $this->listItems = new ArrayCollection();
  156.         $this->basketItems = new ArrayCollection();
  157.         $this->clinicProducts = new ArrayCollection();
  158.         $this->productFavourites = new ArrayCollection();
  159.         $this->productManufacturers = new ArrayCollection();
  160.         $this->productImages = new ArrayCollection();
  161.         $this->productRetails = new ArrayCollection();
  162.     }
  164.     public function getId(): ?int
  165.     {
  166.         return $this->id;
  167.     }
  169.     public function getSubCategory(): ?SubCategories
  170.     {
  171.         return $this->subCategory;
  172.     }
  174.     public function setSubCategory(?SubCategories $subCategory): self
  175.     {
  176.         $this->subCategory = $subCategory;
  178.         return $this;
  179.     }
  181.     public function getIsPublished(): ?bool
  182.     {
  183.         return $this->isPublished;
  184.     }
  186.     public function setIsPublished(bool $isPublished): self
  187.     {
  188.         $this->isPublished = $isPublished;
  190.         return $this;
  191.     }
  193.     public function getIsActive(): ?bool
  194.     {
  195.         return $this->isActive;
  196.     }
  198.     public function setIsActive(bool $isActive): self
  199.     {
  200.         $this->isActive = $isActive;
  202.         return $this;
  203.     }
  205.     public function getName(): ?string
  206.     {
  207.         return $this->name;
  208.     }
  210.     public function setName(string $name): self
  211.     {
  212.         $this->name = $name;
  214.         return $this;
  215.     }
  217.     public function getActiveIngredient(): ?string
  218.     {
  219.         return $this->activeIngredient;
  220.     }
  222.     public function setActiveIngredient(string $activeIngredient): self
  223.     {
  224.         $this->activeIngredient = $activeIngredient;
  226.         return $this;
  227.     }
  229.     public function getImage(): ?string
  230.     {
  231.         return $this->image;
  232.     }
  234.     public function setImage(?string $image): self
  235.     {
  236.         $this->image = $image;
  238.         return $this;
  239.     }
  241.     public function getDescription(): ?string
  242.     {
  243.         return $this->description;
  244.     }
  246.     public function setDescription(?string $description): self
  247.     {
  248.         $this->description = $description;
  250.         return $this;
  251.     }
  253.     public function getDosage(): ?string
  254.     {
  255.         return $this->dosage;
  256.     }
  258.     public function setDosage(?string $dosage): self
  259.     {
  260.         $this->dosage = $dosage;
  262.         return $this;
  263.     }
  265.     public function getSize(): ?string
  266.     {
  267.         return $this->size;
  268.     }
  270.     public function setSize(?string $size): self
  271.     {
  272.         $this->size = $size;
  274.         return $this;
  275.     }
  277.     public function getForm(): ?string
  278.     {
  279.         return $this->form;
  280.     }
  282.     public function setForm(string $form): self
  283.     {
  284.         $this->form = $form;
  286.         return $this;
  287.     }
  289.     public function getUnit(): ?string
  290.     {
  291.         return $this->unit;
  292.     }
  294.     public function setUnit(string $unit): self
  295.     {
  296.         $this->unit = $unit;
  298.         return $this;
  299.     }
  301.     public function getUnitPrice(): ?float
  302.     {
  303.         return $this->unitPrice;
  304.     }
  306.     public function setUnitPrice(float $unitPrice): self
  307.     {
  308.         $this->unitPrice = $unitPrice;
  310.         return $this;
  311.     }
  313.     public function getStockCount(): ?int
  314.     {
  315.         return $this->stockCount;
  316.     }
  318.     public function setStockCount(int $stockCount): self
  319.     {
  320.         $this->stockCount = $stockCount;
  322.         return $this;
  323.     }
  325.     public function getModified(): ?\DateTimeInterface
  326.     {
  327.         return $this->modified;
  328.     }
  330.     public function setModified(\DateTimeInterface $modified): self
  331.     {
  332.         $this->modified = $modified;
  334.         return $this;
  335.     }
  337.     public function getCreated(): ?\DateTimeInterface
  338.     {
  339.         return $this->created;
  340.     }
  342.     public function setCreated(\DateTimeInterface $created): self
  343.     {
  344.         $this->created = $created;
  346.         return $this;
  347.     }
  349.     /**
  350.      * @return Collection|DistributorProducts[]
  351.      */
  352.     public function getDistributorProducts(): Collection
  353.     {
  354.         return $this->distributorProducts;
  355.     }
  357.     public function addDistributorProduct(DistributorProducts $distributorProduct): self
  358.     {
  359.         if (!$this->distributorProducts->contains($distributorProduct)) {
  360.             $this->distributorProducts[] = $distributorProduct;
  361.             $distributorProduct->setProduct($this);
  362.         }
  364.         return $this;
  365.     }
  367.     public function removeDistributorProduct(DistributorProducts $distributorProduct): self
  368.     {
  369.         if ($this->distributorProducts->removeElement($distributorProduct)) {
  370.             // set the owning side to null (unless already changed)
  371.             if ($distributorProduct->getProduct() === $this) {
  372.                 $distributorProduct->setProduct(null);
  373.             }
  374.         }
  376.         return $this;
  377.     }
  379.     /**
  380.      * @return Collection|OrderItems[]
  381.      */
  382.     public function getOrderItems(): Collection
  383.     {
  384.         return $this->orderItems;
  385.     }
  387.     public function addOrderItem(OrderItems $orderItem): self
  388.     {
  389.         if (!$this->orderItems->contains($orderItem)) {
  390.             $this->orderItems[] = $orderItem;
  391.             $orderItem->setProduct($this);
  392.         }
  394.         return $this;
  395.     }
  397.     public function removeOrderItem(OrderItems $orderItem): self
  398.     {
  399.         if ($this->orderItems->removeElement($orderItem)) {
  400.             // set the owning side to null (unless already changed)
  401.             if ($orderItem->getProduct() === $this) {
  402.                 $orderItem->setProduct(null);
  403.             }
  404.         }
  406.         return $this;
  407.     }
  409.     /**
  410.      * @return Collection|ProductNotes[]
  411.      */
  412.     public function getProductNotes(): Collection
  413.     {
  414.         return $this->productNotes;
  415.     }
  417.     public function addProductNote(ProductNotes $productNote): self
  418.     {
  419.         if (!$this->productNotes->contains($productNote)) {
  420.             $this->productNotes[] = $productNote;
  421.             $productNote->setProduct($this);
  422.         }
  424.         return $this;
  425.     }
  427.     public function removeProductNote(ProductNotes $productNote): self
  428.     {
  429.         if ($this->productNotes->removeElement($productNote)) {
  430.             // set the owning side to null (unless already changed)
  431.             if ($productNote->getProduct() === $this) {
  432.                 $productNote->setProduct(null);
  433.             }
  434.         }
  436.         return $this;
  437.     }
  439.     /**
  440.      * @return Collection|ProductReviews[]
  441.      */
  442.     public function getProductReviews(): Collection
  443.     {
  444.         return $this->productReviews;
  445.     }
  447.     public function addProductReview(ProductReviews $productReview): self
  448.     {
  449.         if (!$this->productReviews->contains($productReview)) {
  450.             $this->productReviews[] = $productReview;
  451.             $productReview->setProduct($this);
  452.         }
  454.         return $this;
  455.     }
  457.     public function removeProductReview(ProductReviews $productReview): self
  458.     {
  459.         if ($this->productReviews->removeElement($productReview)) {
  460.             // set the owning side to null (unless already changed)
  461.             if ($productReview->getProduct() === $this) {
  462.                 $productReview->setProduct(null);
  463.             }
  464.         }
  466.         return $this;
  467.     }
  469.     /**
  470.      * @return Collection|AvailabilityTracker[]
  471.      */
  472.     public function getAvailabilityTrackers(): Collection
  473.     {
  474.         return $this->availabilityTrackers;
  475.     }
  477.     public function addAvailabilityTracker(AvailabilityTracker $availabilityTracker): self
  478.     {
  479.         if (!$this->availabilityTrackers->contains($availabilityTracker)) {
  480.             $this->availabilityTrackers[] = $availabilityTracker;
  481.             $availabilityTracker->setProduct($this);
  482.         }
  484.         return $this;
  485.     }
  487.     public function removeAvailabilityTracker(AvailabilityTracker $availabilityTracker): self
  488.     {
  489.         if ($this->availabilityTrackers->removeElement($availabilityTracker)) {
  490.             // set the owning side to null (unless already changed)
  491.             if ($availabilityTracker->getProduct() === $this) {
  492.                 $availabilityTracker->setProduct(null);
  493.             }
  494.         }
  496.         return $this;
  497.     }
  499.     /**
  500.      * @return Collection|Species[]
  501.      */
  502.     public function getProductsSpecies(): Collection
  503.     {
  504.         return $species = $this->productsSpecies;
  505.     }
  507.     /**
  508.      * @return Collection<int, ListItems>
  509.      */
  510.     public function getListItems(): Collection
  511.     {
  512.         return $this->listItems;
  513.     }
  515.     public function addListItem(ListItems $listItem): self
  516.     {
  517.         if (!$this->listItems->contains($listItem)) {
  518.             $this->listItems[] = $listItem;
  519.             $listItem->setProduct($this);
  520.         }
  522.         return $this;
  523.     }
  525.     public function removeListItem(ListItems $listItem): self
  526.     {
  527.         if ($this->listItems->removeElement($listItem)) {
  528.             // set the owning side to null (unless already changed)
  529.             if ($listItem->getProduct() === $this) {
  530.                 $listItem->setProduct(null);
  531.             }
  532.         }
  534.         return $this;
  535.     }
  537.     /**
  538.      * @return Collection<int, BasketItems>
  539.      */
  540.     public function getBasketItems(): Collection
  541.     {
  542.         return $this->basketItems;
  543.     }
  545.     public function addBasketItem(BasketItems $basketItem): self
  546.     {
  547.         if (!$this->basketItems->contains($basketItem)) {
  548.             $this->basketItems[] = $basketItem;
  549.             $basketItem->setProduct($this);
  550.         }
  552.         return $this;
  553.     }
  555.     public function removeBasketItem(BasketItems $basketItem): self
  556.     {
  557.         if ($this->basketItems->removeElement($basketItem)) {
  558.             // set the owning side to null (unless already changed)
  559.             if ($basketItem->getProduct() === $this) {
  560.                 $basketItem->setProduct(null);
  561.             }
  562.         }
  564.         return $this;
  565.     }
  567.     /**
  568.      * @return Collection<int, ClinicProducts>
  569.      */
  570.     public function getClinicProducts(): Collection
  571.     {
  572.         return $this->clinicProducts;
  573.     }
  575.     public function addClinicProduct(ClinicProducts $clinicProduct): self
  576.     {
  577.         if (!$this->clinicProducts->contains($clinicProduct)) {
  578.             $this->clinicProducts[] = $clinicProduct;
  579.             $clinicProduct->setProduct($this);
  580.         }
  582.         return $this;
  583.     }
  585.     public function removeClinicProduct(ClinicProducts $clinicProduct): self
  586.     {
  587.         if ($this->clinicProducts->removeElement($clinicProduct)) {
  588.             // set the owning side to null (unless already changed)
  589.             if ($clinicProduct->getProduct() === $this) {
  590.                 $clinicProduct->setProduct(null);
  591.             }
  592.         }
  594.         return $this;
  595.     }
  597.     /**
  598.      * @return Collection<int, ProductFavourites>
  599.      */
  600.     public function getProductFavourites(): Collection
  601.     {
  602.         return $this->productFavourites;
  603.     }
  605.     public function addProductFavourite(ProductFavourites $productFavourite): self
  606.     {
  607.         if (!$this->productFavourites->contains($productFavourite)) {
  608.             $this->productFavourites[] = $productFavourite;
  609.             $productFavourite->setProduct($this);
  610.         }
  612.         return $this;
  613.     }
  615.     public function removeProductFavourite(ProductFavourites $productFavourite): self
  616.     {
  617.         if ($this->productFavourites->removeElement($productFavourite)) {
  618.             // set the owning side to null (unless already changed)
  619.             if ($productFavourite->getProduct() === $this) {
  620.                 $productFavourite->setProduct(null);
  621.             }
  622.         }
  624.         return $this;
  625.     }
  627.     public function getSku(): ?string
  628.     {
  629.         return $this->sku;
  630.     }
  632.     public function setSku(?string $sku): self
  633.     {
  634.         $this->sku = $sku;
  636.         return $this;
  637.     }
  639.     /**
  640.      * @return Collection<int, ProductManufacturers>
  641.      */
  642.     public function getProductManufacturers(): Collection
  643.     {
  644.         return $this->productManufacturers;
  645.     }
  647.     /**
  648.      * @return Collection<int, ProductImages>
  649.      */
  650.     public function getProductImages(): Collection
  651.     {
  652.         return $this->productImages;
  653.     }
  655.     public function addProductImage(ProductImages $productImage): self
  656.     {
  657.         if (!$this->productImages->contains($productImage)) {
  658.             $this->productImages[] = $productImage;
  659.             $productImage->setProduct($this);
  660.         }
  662.         return $this;
  663.     }
  665.     public function removeProductImage(ProductImages $productImage): self
  666.     {
  667.         if ($this->productImages->removeElement($productImage)) {
  668.             // set the owning side to null (unless already changed)
  669.             if ($productImage->getProduct() === $this) {
  670.                 $productImage->setProduct(null);
  671.             }
  672.         }
  674.         return $this;
  675.     }
  677.     public function getExpiryDateRequired(): ?bool
  678.     {
  679.         return $this->expiryDateRequired;
  680.     }
  682.     public function setExpiryDateRequired(bool $expiryDateRequired): self
  683.     {
  684.         $this->expiryDateRequired = $expiryDateRequired;
  686.         return $this;
  687.     }
  689.     public function getCategory2(): ?Categories2
  690.     {
  691.         return $this->category2;
  692.     }
  694.     public function setCategory2(?Categories2 $category2): self
  695.     {
  696.         $this->category2 = $category2;
  698.         return $this;
  699.     }
  701.     public function getCategory3(): ?Categories3
  702.     {
  703.         return $this->category3;
  704.     }
  706.     public function setCategory3(?Categories3 $category3): self
  707.     {
  708.         $this->category3 = $category3;
  710.         return $this;
  711.     }
  713.     public function getTags(): ?array
  714.     {
  715.         return $this->tags;
  716.     }
  718.     public function setTags(?array $tags): self
  719.     {
  720.         $this->tags = $tags;
  722.         return $this;
  723.     }
  725.     public function getSlug(): ?string
  726.     {
  727.         return $this->slug;
  728.     }
  730.     public function setSlug(?string $slug): self
  731.     {
  732.         $this->slug = $slug;
  734.         return $this;
  735.     }
  737.     public function getCategory(): ?Categories1
  738.     {
  739.         return $this->category;
  740.     }
  742.     public function setCategory(?Categories1 $category): self
  743.     {
  744.         $this->category = $category;
  746.         return $this;
  747.     }
  749.     public function getPriceFrom(): ?float
  750.     {
  751.         return $this->priceFrom;
  752.     }
  754.     public function setPriceFrom(float $priceFrom): self
  755.     {
  756.         $this->priceFrom = $priceFrom;
  758.         return $this;
  759.     }
  761.     public function getDosageUnit(): ?string
  762.     {
  763.         return $this->dosageUnit;
  764.     }
  766.     public function setDosageUnit(?string $dosageUnit): self
  767.     {
  768.         $this->dosageUnit = $dosageUnit;
  770.         return $this;
  771.     }
  773.     public function getManufacturerIds(): ?array
  774.     {
  775.         return $this->manufacturerIds;
  776.     }
  778.     public function setManufacturerIds(?array $manufacturerIds): self
  779.     {
  780.         $this->manufacturerIds = $manufacturerIds;
  782.         return $this;
  783.     }
  785.     /**
  786.      * @return Collection<int, ProductRetail>
  787.      */
  788.     public function getProductRetails(): Collection
  789.     {
  790.         return $this->productRetails;
  791.     }
  793.     public function addProductRetail(ProductRetail $productRetail): self
  794.     {
  795.         if (!$this->productRetails->contains($productRetail)) {
  796.             $this->productRetails[] = $productRetail;
  797.             $productRetail->setProduct($this);
  798.         }
  800.         return $this;
  801.     }
  803.     public function removeProductRetail(ProductRetail $productRetail): self
  804.     {
  805.         if ($this->productRetails->removeElement($productRetail)) {
  806.             // set the owning side to null (unless already changed)
  807.             if ($productRetail->getProduct() === $this) {
  808.                 $productRetail->setProduct(null);
  809.             }
  810.         }
  812.         return $this;
  813.     }
  815.     public function getIsControlled(): ?bool
  816.     {
  817.         return $this->isControlled;
  818.     }
  820.     public function setIsControlled(?bool $isControlled): self
  821.     {
  822.         $this->isControlled = $isControlled;
  824.         return $this;
  825.     }
  826. }