src/Entity/Articles.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ArticlesRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * @ORM\Entity(repositoryClass=ArticlesRepository::class)
  12.  */
  13. class Articles
  14. {
  15.     /**
  16.      * @ORM\Id
  17.      * @ORM\GeneratedValue
  18.      * @ORM\Column(type="integer")
  19.      */
  20.     private $id;
  22.     /**
  23.      * @ORM\Column(type="string", nullable=true)
  24.      */
  25.     private $idPunch = null;
  27.     /**
  28.      * @ORM\Column(type="string", length=255)
  29.      */
  30.     private $name;
  32.     /**
  33.      * @ORM\Column(type="text", nullable=true)
  34.      */
  35.     private $description = null;
  37.     /**
  38.      * @ORM\Column(type="string", length=255, nullable=true)
  39.      */
  40.     private $empties = null;
  42.     /**
  43.      * @ORM\Column(type="float")
  44.      */
  45.     private $stock = 0.0;
  47.     /**
  48.      * @ORM\Column(type="float")
  49.      */
  50.     private $tax = 0.0;
  52.     /**
  53.      * @ORM\ManyToOne(targetEntity=Establishments::class, inversedBy="articles")
  54.      */
  55.     private $supplier;
  57.     /**
  58.      * @ORM\Column(type="string", length=255, nullable=true)
  59.      */
  60.     private $barcode = null;
  62.     /**
  63.      * @ORM\Column(type="float")
  64.      */
  65.     private $priceHtva = 0.0;
  67.     /**
  68.      * @ORM\Column(type="float")
  69.      */
  70.     private $priceTvac = 0.0;
  72.     /**
  73.      * @ORM\Column(type="string", length=255, nullable=true)
  74.      */
  75.     private $intrastatCode = null;
  77.     /**
  78.      * @ORM\Column(type="float")
  79.      */
  80.     private $weight = 0.0;
  82.     /**
  83.      * @ORM\Column(type="string", length=255, nullable=true)
  84.      */
  85.     private $codeTva = null;
  87.     /**
  88.      * @ORM\Column(type="string", length=255, nullable=true)
  89.      */
  90.     private $typeOfPackaging = null;
  92.     /**
  93.      * @ORM\Column(type="string", length=255, nullable=true)
  94.      */
  95.     private $accountingType = null;
  97.     /**
  98.      * @ORM\Column(type="float", nullable=true)
  99.      */
  100.     private $depositValue = null;
  102.     /**
  103.      * @ORM\Column(type="float")
  104.      */
  105.     private $depositValueBottle = 0.0;
  107.     /**
  108.      * @ORM\ManyToOne(targetEntity=Units::class, inversedBy="articles")
  109.      */
  110.     private $unit;
  112.     /**
  113.      * @ORM\OneToMany(targetEntity=ShoppingCart::class, mappedBy="article")
  114.      */
  115.     private $shoppingCarts;
  117.     /**
  118.      * @ORM\OneToMany(targetEntity=OrderArticle::class, mappedBy="article")
  119.      */
  120.     private $orderArticles;
  122.     /**
  123.      * @ORM\ManyToMany(targetEntity=DiscountGroups::class, inversedBy="articles")
  124.      */
  125.     private $discountGroups;
  127.     /**
  128.      * @ORM\ManyToMany(targetEntity=ItemGroups::class, inversedBy="articles")
  129.      */
  130.     private $itemGroups;
  132.     /**
  133.      * @ORM\ManyToMany(targetEntity=TagGroups::class, mappedBy="articles")
  134.      */
  135.     private $tagGroups;
  137.     /**
  138.      * @ORM\Column(type="datetime")
  139.      */
  140.     private $createdAt;
  142.     /**
  143.      * @ORM\Column(type="datetime")
  144.      */
  145.     private $updatedAt;
  147.     /**
  148.      * @ORM\OneToMany(targetEntity=TarifsArticle::class, mappedBy="article")
  149.      */
  150.     private $tarifsArticles;
  152.     /**
  153.      * @ORM\Column(type="boolean")
  154.      */
  155.     private $deleted = false;
  157.     /**
  158.      * @ORM\Column(type="string", length=5000, nullable=true)
  159.      */
  160.     private $pathImage = null;
  162.     /**
  163.      * @ORM\Column(type="float", nullable=true)
  164.      */
  165.     private $weightValue = null;
  167.     /**
  168.      * @ORM\Column(type="integer")
  169.      */
  170.     private $maxQuantity = 0;
  172.     /**
  173.      * @ORM\Column(type="integer")
  174.      */
  175.     private $minQuantity = 0;
  177.     /**
  178.      * @ORM\OneToMany(targetEntity=Favorite::class, mappedBy="Article")
  179.      */
  180.     private $favorites;
  182.     /**
  183.      * @ORM\OneToMany(targetEntity=RestrictionArticle::class, mappedBy="article")
  184.      */
  185.     private $restrictionArticles;
  187.     /**
  188.      * @ORM\Column(type="boolean")
  189.      */
  190.     private $forMobileApp = 1;
  192.     /**
  193.      * @ORM\ManyToMany(targetEntity=ChildTags::class, mappedBy="articles")
  194.      */
  195.     private $childTags;
  197.     /**
  198.      * @ORM\OneToMany(targetEntity=Banner::class, mappedBy="article")
  199.      */
  200.     private $banners;
  202.     /**
  203.      * @ORM\OneToMany(targetEntity=Promotions::class, mappedBy="article")
  204.      */
  205.     private $promotions;
  207.     /**
  208.      * @ORM\Column(type="text", nullable=true)
  209.      */
  210.     private $infoTextPunch;
  212.     /**
  213.      * @ORM\Column(type="string", length=255, nullable=true)
  214.      */
  215.     private $webshopPunch;
  217.     /**
  218.      * @ORM\OneToMany(targetEntity=RelationArticles::class, mappedBy="parentArticle")
  219.      */
  220.     private $relationArticleParent;
  222.     /**
  223.      * @ORM\OneToMany(targetEntity=RelationArticles::class, mappedBy="childArticle")
  224.      */
  225.     private $realtionArticleChild;
  227.     /**
  228.      * @ORM\OneToMany(targetEntity=ArticleOrderOutOfStock::class, mappedBy="article")
  229.      */
  230.     private $articleOrderOutOfStocks;
  232.     /**
  233.      * @ORM\ManyToMany(targetEntity=FilterChild::class, mappedBy="article")
  234.      */
  235.     private $filterChildren;
  237.     /**
  238.      * @ORM\Column(type="boolean")
  239.      */
  240.     private $newArticle = 1;
  242.     /**
  243.      * @ORM\OneToMany(targetEntity=PromotionItem::class, mappedBy="article")
  244.      */
  245.     private $promotionItems;
  247.     /**
  248.      * @ORM\OneToMany(targetEntity=NewArticle::class, mappedBy="article")
  249.      */
  250.     private $newArticles;
  252.     /**
  253.      * @ORM\Column(type="integer")
  254.      */
  255.     private $numberOfArticle = 1;
  257.     /**
  258.      * @ORM\Column(type="boolean")
  259.      */
  260.     private $modifiedVisibility;
  262.     /**
  263.      * @ORM\OneToMany(targetEntity=BackOrder::class, mappedBy="article")
  264.      */
  265.     private $backOrders;
  267.     /**
  268.      * @ORM\ManyToOne(targetEntity=Users::class, inversedBy="articles")
  269.      */
  270.     private $visibleBy = null;
  272.     /**
  273.      * @ORM\Column(type="boolean")
  274.      */
  275.     private $modifyQuantity = false;
  278.     public function __construct()
  279.     {
  280.         $this->updatedAt = New \DateTime();
  281.         $this->createdAt = New \DateTime();
  282.         $this->shoppingCarts = new ArrayCollection();
  283.         $this->orderArticles = new ArrayCollection();
  284.         $this->discountGroups = new ArrayCollection();
  285.         $this->itemGroups = new ArrayCollection();
  286.         $this->tagGroups = new ArrayCollection();
  287.         $this->tarifsArticles = new ArrayCollection();
  288.         $this->favorites = new ArrayCollection();
  289.         $this->restrictionArticles = new ArrayCollection();
  290.         $this->childTags = new ArrayCollection();
  291.         $this->banners = new ArrayCollection();
  292.         $this->promotions = new ArrayCollection();
  293.         $this->relationArticleParent = new ArrayCollection();
  294.         $this->realtionArticleChild = new ArrayCollection();
  295.         $this->articleOrderOutOfStocks = new ArrayCollection();
  296.         $this->filterChildren = new ArrayCollection();
  297.         $this->promotionItems = new ArrayCollection();
  298.         $this->newArticles = new ArrayCollection();
  299.         $this->backOrders = new ArrayCollection();
  300.     }
  302.     public function getId(): ?int
  303.     {
  304.         return $this->id;
  305.     }
  307.     public function getIdPunch(): ?string
  308.     {
  309.         return $this->idPunch;
  310.     }
  312.     public function setIdPunch(?string $idPunch): self
  313.     {
  314.         $this->idPunch = $idPunch;
  316.         return $this;
  317.     }
  319.     public function getName(): ?string
  320.     {
  321.         return $this->name;
  322.     }
  324.     public function setName(string $name): self
  325.     {
  326.         $this->name = $name;
  328.         return $this;
  329.     }
  331.     public function getDescription(): ?string
  332.     {
  333.         // return $this->description;
  334.         return $this->infoTextPunch;
  335.     }
  337.     public function setDescription(?string $description): self
  338.     {
  339.         $this->description = $description;
  341.         return $this;
  342.     }
  344.     public function getEmpties(): ?string
  345.     {
  346.         return $this->empties;
  347.     }
  349.     public function setEmpties(?string $empties): self
  350.     {
  351.         $this->empties = $empties;
  353.         return $this;
  354.     }
  356.     public function getStock(): ?float
  357.     {
  358.         return $this->stock;
  359.     }
  361.     public function setStock(float $stock): self
  362.     {
  363.         $this->stock = $stock;
  365.         return $this;
  366.     }
  368.     public function getTax(): ?float
  369.     {
  370.         return $this->tax;
  371.     }
  373.     public function setTax(float $tax): self
  374.     {
  375.         $this->tax = $tax;
  377.         return $this;
  378.     }
  380.     public function getSupplier(): ?Establishments
  381.     {
  382.         return $this->supplier;
  383.     }
  385.     public function setSupplier(?Establishments $supplier): self
  386.     {
  387.         $this->supplier = $supplier;
  389.         return $this;
  390.     }
  392.     public function getBarcode(): ?string
  393.     {
  394.         return $this->barcode;
  395.     }
  397.     public function setBarcode(?string $barcode): self
  398.     {
  399.         $this->barcode = $barcode;
  401.         return $this;
  402.     }
  404.     public function getPriceHtva(): ?float
  405.     {
  406.         return $this->priceHtva;
  407.     }
  409.     public function setPriceHtva(float $priceHtva): self
  410.     {
  411.         $this->priceHtva = $priceHtva;
  413.         return $this;
  414.     }
  416.     public function getPriceTvac(): ?float
  417.     {
  418.         return $this->priceTvac;
  419.     }
  421.     public function setPriceTvac(float $priceTvac): self
  422.     {
  423.         $this->priceTvac = $priceTvac;
  425.         return $this;
  426.     }
  428.     public function getIntrastatCode(): ?string
  429.     {
  430.         return $this->intrastatCode;
  431.     }
  433.     public function setIntrastatCode(?string $intrastatCode): self
  434.     {
  435.         $this->intrastatCode = $intrastatCode;
  437.         return $this;
  438.     }
  440.     public function getWeight(): ?float
  441.     {
  442.         return $this->weight;
  443.     }
  445.     public function setWeight(float $weight): self
  446.     {
  447.         $this->weight = $weight;
  449.         return $this;
  450.     }
  452.     public function getCodeTva(): ?string
  453.     {
  454.         return $this->codeTva;
  455.     }
  457.     public function setCodeTva(?string $codeTva): self
  458.     {
  459.         $this->codeTva = $codeTva;
  461.         return $this;
  462.     }
  464.     public function getTypeOfPackaging(): ?string
  465.     {
  466.         return $this->typeOfPackaging;
  467.     }
  469.     public function setTypeOfPackaging(?string $typeOfPackaging): self
  470.     {
  471.         $this->typeOfPackaging = $typeOfPackaging;
  473.         return $this;
  474.     }
  476.     public function getAccountingType(): ?string
  477.     {
  478.         return $this->accountingType;
  479.     }
  481.     public function setAccountingType(?string $accountingType): self
  482.     {
  483.         $this->accountingType = $accountingType;
  485.         return $this;
  486.     }
  488.     public function getDepositValue(): ?float
  489.     {
  490.         return $this->depositValue;
  491.     }
  493.     public function setDepositValue(?float $depositValue): self
  494.     {
  495.         $this->depositValue = $depositValue;
  497.         return $this;
  498.     }
  500.     public function getDepositValueBottle(): ?float
  501.     {
  502.         return $this->depositValueBottle;
  503.     }
  505.     public function setDepositValueBottle(float $depositValueBottle): self
  506.     {
  507.         $this->depositValueBottle = $depositValueBottle;
  509.         return $this;
  510.     }
  512.     public function getUnit(): ?Units
  513.     {
  514.         return $this->unit;
  515.     }
  517.     public function setUnit(?Units $unit): self
  518.     {
  519.         $this->unit = $unit;
  521.         return $this;
  522.     }
  524.     /**
  525.      * @return Collection<int, ShoppingCart>
  526.      */
  527.     public function getShoppingCarts(): Collection
  528.     {
  529.         return $this->shoppingCarts;
  530.     }
  532.     public function addShoppingCart(ShoppingCart $shoppingCart): self
  533.     {
  534.         if (!$this->shoppingCarts->contains($shoppingCart)) {
  535.             $this->shoppingCarts[] = $shoppingCart;
  536.             $shoppingCart->setArticle($this);
  537.         }
  539.         return $this;
  540.     }
  542.     public function removeShoppingCart(ShoppingCart $shoppingCart): self
  543.     {
  544.         if ($this->shoppingCarts->removeElement($shoppingCart)) {
  545.             // set the owning side to null (unless already changed)
  546.             if ($shoppingCart->getArticle() === $this) {
  547.                 $shoppingCart->setArticle(null);
  548.             }
  549.         }
  551.         return $this;
  552.     }
  554.     /**
  555.      * @return Collection<int, OrderArticle>
  556.      */
  557.     public function getOrderArticles(): Collection
  558.     {
  559.         return $this->orderArticles;
  560.     }
  562.     public function addOrderArticle(OrderArticle $orderArticle): self
  563.     {
  564.         if (!$this->orderArticles->contains($orderArticle)) {
  565.             $this->orderArticles[] = $orderArticle;
  566.             $orderArticle->setArticle($this);
  567.         }
  569.         return $this;
  570.     }
  572.     public function removeOrderArticle(OrderArticle $orderArticle): self
  573.     {
  574.         if ($this->orderArticles->removeElement($orderArticle)) {
  575.             // set the owning side to null (unless already changed)
  576.             if ($orderArticle->getArticle() === $this) {
  577.                 $orderArticle->setArticle(null);
  578.             }
  579.         }
  581.         return $this;
  582.     }
  584.     /**
  585.      * @return Collection<int, DiscountGroups>
  586.      */
  587.     public function getDiscountGroups(): Collection
  588.     {
  589.         return $this->discountGroups;
  590.     }
  592.     public function addDiscountGroup(DiscountGroups $discountGroup): self
  593.     {
  594.         if (!$this->discountGroups->contains($discountGroup)) {
  595.             $this->discountGroups[] = $discountGroup;
  596.         }
  598.         return $this;
  599.     }
  601.     public function removeDiscountGroup(DiscountGroups $discountGroup): self
  602.     {
  603.         $this->discountGroups->removeElement($discountGroup);
  605.         return $this;
  606.     }
  608.     /**
  609.      * @return Collection<int, ItemGroups>
  610.      */
  611.     public function getItemGroups(): Collection
  612.     {
  613.         return $this->itemGroups;
  614.     }
  616.     public function addItemGroup(ItemGroups $itemGroup): self
  617.     {
  618.         if (!$this->itemGroups->contains($itemGroup)) {
  619.             $this->itemGroups[] = $itemGroup;
  620.         }
  622.         return $this;
  623.     }
  625.     public function removeItemGroup(ItemGroups $itemGroup): self
  626.     {
  627.         $this->itemGroups->removeElement($itemGroup);
  629.         return $this;
  630.     }
  632.     /**
  633.      * @return Collection<int, TagGroups>
  634.      */
  635.     public function getTagGroups(): Collection
  636.     {
  637.         return $this->tagGroups;
  638.     }
  640.     public function addTagGroup(TagGroups $tagGroup): self
  641.     {
  642.         if (!$this->tagGroups->contains($tagGroup)) {
  643.             $this->tagGroups[] = $tagGroup;
  644.             $tagGroup->addArticle($this);
  645.         }
  647.         return $this;
  648.     }
  650.     public function removeTagGroup(TagGroups $tagGroup): self
  651.     {
  652.         if ($this->tagGroups->removeElement($tagGroup)) {
  653.             $tagGroup->removeArticle($this);
  654.         }
  656.         return $this;
  657.     }
  659.     public function getCreatedAt(): ?\DateTimeInterface
  660.     {
  661.         return $this->createdAt;
  662.     }
  664.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  665.     {
  666.         $this->createdAt = $createdAt;
  668.         return $this;
  669.     }
  671.     public function getUpdatedAt(): ?\DateTimeInterface
  672.     {
  673.         return $this->updatedAt;
  674.     }
  676.     public function setUpdatedAt(\DateTimeInterface $updatedAt): self
  677.     {
  678.         $this->updatedAt = $updatedAt;
  680.         return $this;
  681.     }
  683.     /**
  684.      * @return Collection<int, TarifsArticle>
  685.      */
  686.     public function getTarifsArticles(): Collection
  687.     {
  688.         return $this->tarifsArticles;
  689.     }
  691.     public function addTarifsArticle(TarifsArticle $tarifsArticle): self
  692.     {
  693.         if (!$this->tarifsArticles->contains($tarifsArticle)) {
  694.             $this->tarifsArticles[] = $tarifsArticle;
  695.             $tarifsArticle->setArticle($this);
  696.         }
  698.         return $this;
  699.     }
  701.     public function removeTarifsArticle(TarifsArticle $tarifsArticle): self
  702.     {
  703.         if ($this->tarifsArticles->removeElement($tarifsArticle)) {
  704.             // set the owning side to null (unless already changed)
  705.             if ($tarifsArticle->getArticle() === $this) {
  706.                 $tarifsArticle->setArticle(null);
  707.             }
  708.         }
  710.         return $this;
  711.     }
  713.     public function isDeleted(): ?bool
  714.     {
  715.         return $this->deleted;
  716.     }
  718.     public function setDeleted(bool $deleted): self
  719.     {
  720.         $this->deleted = $deleted;
  722.         return $this;
  723.     }
  725.     public function getPathImage(): ?string
  726.     {
  727.         return $this->pathImage;
  728.     }
  730.     public function setPathImage(?string $pathImage): self
  731.     {
  732.         $this->pathImage = $pathImage;
  734.         return $this;
  735.     }
  737.     public function getWeightValue(): ?float
  738.     {
  739.         return $this->weightValue;
  740.     }
  742.     public function setWeightValue(?float $weightValue): self
  743.     {
  744.         $this->weightValue = $weightValue;
  745.         return $this;
  746.     }
  747.     /**
  748.      * @return Collection<int, Favorite>
  749.      */
  750.     public function getFavorites(): Collection
  751.     {
  752.         return $this->favorites;
  753.     }
  755.     public function addFavorite(Favorite $favorite): self
  756.     {
  757.         if (!$this->favorites->contains($favorite)) {
  758.             $this->favorites[] = $favorite;
  759.             $favorite->setArticle($this);
  760.         }
  762.         return $this;
  763.     }
  765.     public function getMaxQuantity(): ?int
  766.     {
  767.         return $this->maxQuantity;
  768.     }
  770.     public function setMaxQuantity(int $maxQuantity): self
  771.     {
  772.         $this->maxQuantity = $maxQuantity;
  774.         return $this;
  775.     }
  777.     public function getminQuantity(): ?int
  778.     {
  779.         return $this->minQuantity;
  780.     }
  782.     public function setminQuantity(int $minQuantity): self
  783.     {
  784.         $this->minQuantity = $minQuantity;
  785.         return $this;
  786.     }
  788.     public function removeFavorite(Favorite $favorite): self
  789.     {
  790.         if ($this->favorites->removeElement($favorite)) {
  791.             // set the owning side to null (unless already changed)
  792.             if ($favorite->getArticle() === $this) {
  793.                 $favorite->setArticle(null);
  794.             }
  795.         }
  797.         return $this;
  798.     }
  800.     /**
  801.      * @return Collection<int, RestrictionArticle>
  802.      */
  803.     public function getRestrictionArticles(): Collection
  804.     {
  805.         return $this->restrictionArticles;
  806.     }
  808.     public function addRestrictionArticle(RestrictionArticle $restrictionArticle): self
  809.     {
  810.         if (!$this->restrictionArticles->contains($restrictionArticle)) {
  811.             $this->restrictionArticles[] = $restrictionArticle;
  812.             $restrictionArticle->setArticle($this);
  813.         }
  815.         return $this;
  816.     }
  818.     public function removeRestrictionArticle(RestrictionArticle $restrictionArticle): self
  819.     {
  820.         if ($this->restrictionArticles->removeElement($restrictionArticle)) {
  821.             // set the owning side to null (unless already changed)
  822.             if ($restrictionArticle->getArticle() === $this) {
  823.                 $restrictionArticle->setArticle(null);
  824.             }
  825.         }
  827.         return $this;
  828.     }
  830.     public function isForMobileApp(): ?bool
  831.     {
  832.         return $this->forMobileApp;
  833.     }
  835.     public function setForMobileApp(bool $forMobileApp): self
  836.     {
  837.         $this->forMobileApp = $forMobileApp;
  839.         return $this;
  840.     }
  842.     /**
  843.      * @return Collection<int, ChildTags>
  844.      */
  845.     public function getChildTags(): Collection
  846.     {
  847.         return $this->childTags;
  848.     }
  850.     public function addChildTag(ChildTags $childTag): self
  851.     {
  852.         if (!$this->childTags->contains($childTag)) {
  853.             $this->childTags[] = $childTag;
  854.             $childTag->addArticle($this);
  855.         }
  857.         return $this;
  858.     }
  860.     public function removeChildTag(ChildTags $childTag): self
  861.     {
  862.         if ($this->childTags->removeElement($childTag)) {
  863.             $childTag->removeArticle($this);
  864.         }
  866.         return $this;
  867.     }
  869.     /**
  870.      * @return Collection<int, Banner>
  871.      */
  872.     public function getBanners(): Collection
  873.     {
  874.         return $this->banners;
  875.     }
  877.     public function addBanner(Banner $banner): self
  878.     {
  879.         if (!$this->banners->contains($banner)) {
  880.             $this->banners[] = $banner;
  881.             $banner->setArticle($this);
  882.         }
  884.         return $this;
  885.     }
  887.     public function removeBanner(Banner $banner): self
  888.     {
  889.         if ($this->banners->removeElement($banner)) {
  890.             // set the owning side to null (unless already changed)
  891.             if ($banner->getArticle() === $this) {
  892.                 $banner->setArticle(null);
  893.             }
  894.         }
  896.         return $this;
  897.     }
  899.     /**
  900.      * @return Collection<int, Promotions>
  901.      */
  902.     public function getPromotions(): Collection
  903.     {
  904.         return $this->promotions;
  905.     }
  907.     public function addPromotion(Promotions $promotion): self
  908.     {
  909.         if (!$this->promotions->contains($promotion)) {
  910.             $this->promotions[] = $promotion;
  911.             $promotion->setArticle($this);
  912.         }
  914.         return $this;
  915.     }
  917.     public function removePromotion(Promotions $promotion): self
  918.     {
  919.         if ($this->promotions->removeElement($promotion)) {
  920.             // set the owning side to null (unless already changed)
  921.             if ($promotion->getArticle() === $this) {
  922.                 $promotion->setArticle(null);
  923.             }
  924.         }
  926.         return $this;
  927.     }
  929.     public function getInfoTextPunch(): ?string
  930.     {
  931.         return $this->infoTextPunch;
  932.     }
  934.     public function setInfoTextPunch(?string $infoTextPunch): self
  935.     {
  936.         $this->infoTextPunch = $infoTextPunch;
  938.         return $this;
  939.     }
  941.     public function getWebshopPunch(): ?string
  942.     {
  943.         return $this->webshopPunch;
  944.     }
  946.     public function setWebshopPunch(?string $webshopPunch): self
  947.     {
  948.         $this->webshopPunch = $webshopPunch;
  950.         return $this;
  951.     }
  953.     /**
  954.      * @return Collection<int, RelationArticles>
  955.      */
  956.     public function getRelationArticleParent(): Collection
  957.     {
  958.         return $this->relationArticleParent;
  959.     }
  961.     public function addRelationArticleParent(RelationArticles $relationArticleParent): self
  962.     {
  963.         if (!$this->relationArticleParent->contains($relationArticleParent)) {
  964.             $this->relationArticleParent[] = $relationArticleParent;
  965.             $relationArticleParent->setParentArticle($this);
  966.         }
  968.         return $this;
  969.     }
  971.     public function removeRelationArticleParent(RelationArticles $relationArticleParent): self
  972.     {
  973.         if ($this->relationArticleParent->removeElement($relationArticleParent)) {
  974.             // set the owning side to null (unless already changed)
  975.             if ($relationArticleParent->getParentArticle() === $this) {
  976.                 $relationArticleParent->setParentArticle(null);
  977.             }
  978.         }
  980.         return $this;
  981.     }
  983.     /**
  984.      * @return Collection<int, RelationArticles>
  985.      */
  986.     public function getRealtionArticleChild(): Collection
  987.     {
  988.         return $this->realtionArticleChild;
  989.     }
  991.     public function addRealtionArticleChild(RelationArticles $realtionArticleChild): self
  992.     {
  993.         if (!$this->realtionArticleChild->contains($realtionArticleChild)) {
  994.             $this->realtionArticleChild[] = $realtionArticleChild;
  995.             $realtionArticleChild->setChildArticle($this);
  996.         }
  998.         return $this;
  999.     }
  1001.     public function removeRealtionArticleChild(RelationArticles $realtionArticleChild): self
  1002.     {
  1003.         if ($this->realtionArticleChild->removeElement($realtionArticleChild)) {
  1004.             // set the owning side to null (unless already changed)
  1005.             if ($realtionArticleChild->getChildArticle() === $this) {
  1006.                 $realtionArticleChild->setChildArticle(null);
  1007.             }
  1008.         }
  1010.         return $this;
  1011.     }
  1013.     /**
  1014.      * @return Collection<int, ArticleOrderOutOfStock>
  1015.      */
  1016.     public function getArticleOrderOutOfStocks(): Collection
  1017.     {
  1018.         return $this->articleOrderOutOfStocks;
  1019.     }
  1021.     public function addArticleOrderOutOfStock(ArticleOrderOutOfStock $articleOrderOutOfStock): self
  1022.     {
  1023.         if (!$this->articleOrderOutOfStocks->contains($articleOrderOutOfStock)) {
  1024.             $this->articleOrderOutOfStocks[] = $articleOrderOutOfStock;
  1025.             $articleOrderOutOfStock->setArticle($this);
  1026.         }
  1028.         return $this;
  1029.     }
  1031.     public function removeArticleOrderOutOfStock(ArticleOrderOutOfStock $articleOrderOutOfStock): self
  1032.     {
  1033.         if ($this->articleOrderOutOfStocks->removeElement($articleOrderOutOfStock)) {
  1034.             // set the owning side to null (unless already changed)
  1035.             if ($articleOrderOutOfStock->getArticle() === $this) {
  1036.                 $articleOrderOutOfStock->setArticle(null);
  1037.             }
  1038.         }
  1040.         return $this;
  1041.     }
  1043.     /**
  1044.      * @return Collection<int, FilterChild>
  1045.      */
  1046.     public function getFilterChildren(): Collection
  1047.     {
  1048.         return $this->filterChildren;
  1049.     }
  1051.     public function addFilterChild(FilterChild $filterChild): self
  1052.     {
  1053.         if (!$this->filterChildren->contains($filterChild)) {
  1054.             $this->filterChildren[] = $filterChild;
  1055.             $filterChild->addArticle($this);
  1056.         }
  1058.         return $this;
  1059.     }
  1061.     public function removeFilterChild(FilterChild $filterChild): self
  1062.     {
  1063.         if ($this->filterChildren->removeElement($filterChild)) {
  1064.             $filterChild->removeArticle($this);
  1065.         }
  1067.         return $this;
  1068.     }
  1070.     public function isNewArticle(): ?bool
  1071.     {
  1072.         return $this->newArticle;
  1073.     }
  1075.     public function setNewArticle(bool $newArticle): self
  1076.     {
  1077.         $this->newArticle = $newArticle;
  1079.         return $this;
  1080.     }
  1082.     public function getNumberOfArticle(): ?int
  1083.     {
  1084.         return $this->numberOfArticle;
  1085.     }
  1087.     public function setNumberOfArticle(int $numberOfArticle): self
  1088.     {
  1089.         $this->numberOfArticle = $numberOfArticle;
  1091.         return $this;
  1092.     }
  1094.     /**
  1095.      * @return Collection<int, PromotionItem>
  1096.      */
  1097.     public function getPromotionItems(): Collection
  1098.     {
  1099.         return $this->promotionItems;
  1100.     }
  1102.     public function addPromotionItem(PromotionItem $promotionItem): self
  1103.     {
  1104.         if (!$this->promotionItems->contains($promotionItem)) {
  1105.             $this->promotionItems[] = $promotionItem;
  1106.             $promotionItem->setArticle($this);
  1107.         }
  1108.         return $this;
  1109.     }
  1111.     /**
  1112.      * @return Collection<int, NewArticle>
  1113.      */
  1114.     public function getNewArticles(): Collection
  1115.     {
  1116.         return $this->newArticles;
  1117.     }
  1119.     public function addNewArticle(NewArticle $newArticle): self
  1120.     {
  1121.         if (!$this->newArticles->contains($newArticle)) {
  1122.             $this->newArticles[] = $newArticle;
  1123.             $newArticle->setArticle($this);
  1124.         }
  1126.         return $this;
  1127.     }
  1130.     public function removePromotionItem(PromotionItem $promotionItem): self
  1131.     {
  1132.         if ($this->promotionItems->removeElement($promotionItem)) {
  1133.             // set the owning side to null (unless already changed)
  1134.             if ($promotionItem->getArticle() === $this) {
  1135.                 $promotionItem->setArticle(null);
  1136.             }
  1137.         }
  1138.         return $this;
  1139.     }
  1141.     public function removeNewArticle(NewArticle $newArticle): self
  1142.     {
  1143.         if ($this->newArticles->removeElement($newArticle)) {
  1144.             // set the owning side to null (unless already changed)
  1145.             if ($newArticle->getArticle() === $this) {
  1146.                 $newArticle->setArticle(null);
  1147.             }
  1148.         }
  1150.         return $this;
  1151.     }
  1153.     public function isModifiedVisibility(): ?bool
  1154.     {
  1155.         return $this->modifiedVisibility;
  1156.     }
  1158.     public function setModifiedVisibility(bool $modifiedVisibility): self
  1159.     {
  1160.         $this->modifiedVisibility = $modifiedVisibility;
  1162.         return $this;
  1163.     }
  1165.     /**
  1166.      * @return Collection<int, BackOrder>
  1167.      */
  1168.     public function getBackOrders(): Collection
  1169.     {
  1170.         return $this->backOrders;
  1171.     }
  1173.     public function addBackOrder(BackOrder $backOrder): self
  1174.     {
  1175.         if (!$this->backOrders->contains($backOrder)) {
  1176.             $this->backOrders[] = $backOrder;
  1177.             $backOrder->setArticle($this);
  1178.         }
  1180.         return $this;
  1181.     }
  1183.     public function removeBackOrder(BackOrder $backOrder): self
  1184.     {
  1185.         if ($this->backOrders->removeElement($backOrder)) {
  1186.             // set the owning side to null (unless already changed)
  1187.             if ($backOrder->getArticle() === $this) {
  1188.                 $backOrder->setArticle(null);
  1189.             }
  1190.         }
  1192.         return $this;
  1193.     }
  1195.     public function getVisibleBy(): ?Users
  1196.     {
  1197.         return $this->visibleBy;
  1198.     }
  1200.     public function setVisibleBy(?Users $visibleBy): self
  1201.     {
  1202.         $this->visibleBy = $visibleBy;
  1204.         return $this;
  1205.     }
  1207.     public function isModifyQuantity(): ?bool
  1208.     {
  1209.         return $this->modifyQuantity;
  1210.     }
  1212.     public function setModifyQuantity(bool $modifyQuantity): self
  1213.     {
  1214.         $this->modifyQuantity = $modifyQuantity;
  1216.         return $this;
  1217.     }
  1219. }