src/Entity/SubSubCategory.php line 20

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\SubSubCategoryRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Gedmo\Mapping\Annotation as Gedmo;
  10. use Knp\DoctrineBehaviors\Contract\Entity\TranslatableInterface;
  11. use Knp\DoctrineBehaviors\Model\Translatable\TranslatableTrait;
  12. use Symfony\Component\HttpFoundation\File\File;
  13. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  14. use Symfony\Component\Validator\Constraints as Assert;
  16. /**
  17.  * @Vich\Uploadable
  18.  * @ORM\Entity(repositoryClass=SubSubCategoryRepository::class)
  19.  */
  20. class SubSubCategory implements TranslatableInterface
  21. {
  22.     use TranslatableTrait;
  24.     public function __call($method, $arguments)
  25.     {
  26.         return $this->proxyCurrentLocaleTranslation($method, $arguments);
  27.     }
  29.     public function __get($name)
  30.     {
  31.         $method = 'get' . ucfirst($name);
  32.         $arguments = [];
  33.         return $this->proxyCurrentLocaleTranslation($method, $arguments);
  34.     }
  36.     public function __toString()
  37.     {
  38.         return "#" . $this->id . " " . $this->getTitle();
  39.     }
  41.     /**
  42.      * @ORM\Id
  43.      * @ORM\GeneratedValue
  44.      * @ORM\Column(type="integer")
  45.      */
  46.     private $id;
  48.     /**
  49.      * @Gedmo\SortableGroup()
  50.      * @Assert\NotBlank()
  51.      * @ORM\ManyToOne(targetEntity=SubCategory::class, inversedBy="subSubCategories")
  52.      */
  53.     private $subCategory;
  55.     /**
  56.      * @ORM\OneToMany(targetEntity=Product::class, mappedBy="subSubCategory")
  57.      */
  58.     private $products;
  60.     /**
  61.        * NOTE: This is not a mapped field of entity metadata, just a simple property.
  62.        * @Vich\UploadableField(mapping="subSubCategoryIcon", fileNameProperty="subSubCategoryIconFileName", size="subSubCategoryIconFileSize")
  63.        * @Assert\File(
  64.        *     maxSize = "1200k"
  65.        * )
  66.        *
  67.        * @var File
  68.        */
  69.       private $subSubCategoryIconFile;
  71.       /**
  72.        * @ORM\Column(type="string", length=255, nullable=true)
  73.        *
  74.        * @var string
  75.        */
  76.       private $subSubCategoryIconFileName;
  78.     /**
  79.        * NOTE: This is not a mapped field of entity metadata, just a simple property.
  80.        * @Vich\UploadableField(mapping="subSubCategoryBg", fileNameProperty="subSubCategoryBgFileName", size="subSubCategoryBgFileSize")
  81.        * @Assert\Expression("this.getSubSubCategoryBgFile() or this.getSubSubCategoryBgFileName()", message = "Veuillez sélectionner un fichier")
  82.        * @Assert\File(
  83.        *     maxSize = "1200k"
  84.        * )
  85.        *
  86.        * @var File
  87.        */
  88.       private $subSubCategoryBgFile;
  90.       /**
  91.        * @ORM\Column(type="string", length=255, nullable=true)
  92.        *
  93.        * @var string
  94.        */
  95.       private $subSubCategoryBgFileName;
  97.       /**
  98.        * @ORM\Column(type="integer", nullable=true)
  99.        *
  100.        * @var integer
  101.        */
  102.       private $subSubCategoryBgFileSize;
  104.       /**
  105.        * @ORM\Column(type="datetime", nullable=true)
  106.        *
  107.        * @var \DateTime
  108.        */
  109.       private $subSubCategoryBgFileUpdatedAt;
  111.       /**
  112.        * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  113.        * of 'UploadedFile' is injected into this setter to trigger the  update. If this
  114.        * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  115.        * must be able to accept an instance of 'File' as the bundle will inject one here
  116.        * during Doctrine hydration.
  117.        *
  118.        * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile $image
  119.        */
  120.       public function setSubSubCategoryBgFile(File $image = null) {
  121.           $this->subSubCategoryBgFile = $image;
  123.           if (null !== $image) {
  124.   // It is required that at least one field changes if you are using doctrine
  125.   // otherwise the event listeners won't be called and the file is lost
  126.               $this->subSubCategoryBgFileUpdatedAt = new \DateTimeImmutable();
  127.           }
  128.       }  public function getSubSubCategoryBgFile() {
  129.           return $this->subSubCategoryBgFile;
  130.       }
  131.        public function getSubSubCategoryBgFileName(): ?string
  132.       {
  133.           return $this->subSubCategoryBgFileName;
  134.       }
  136.       public function setSubSubCategoryBgFileName(?string $subSubCategoryBgFileName): self
  137.       {
  138.           $this->subSubCategoryBgFileName = $subSubCategoryBgFileName;
  140.           return $this;
  141.       }
  143.       public function getSubSubCategoryBgFileSize(): ?int
  144.       {
  145.           return $this->subSubCategoryBgFileSize;
  146.       }
  148.       public function setSubSubCategoryBgFileSize(?int $subSubCategoryBgFileSize): self
  149.       {
  150.           $this->subSubCategoryBgFileSize = $subSubCategoryBgFileSize;
  152.           return $this;
  153.       }
  155.       public function getSubSubCategoryBgFileUpdatedAt(): ?\DateTimeInterface
  156.       {
  157.           return $this->subSubCategoryBgFileUpdatedAt;
  158.       }
  160.       public function setSubSubCategoryBgFileUpdatedAt(?\DateTimeInterface $subSubCategoryBgFileUpdatedAt): self
  161.       {
  162.           $this->subSubCategoryBgFileUpdatedAt = $subSubCategoryBgFileUpdatedAt;
  164.           return $this;
  165.       }
  166.       /**
  167.        * @ORM\Column(type="integer", nullable=true)
  168.        *
  169.        * @var integer
  170.        */
  171.       private $subSubCategoryIconFileSize;
  173.       /**
  174.        * @ORM\Column(type="datetime", nullable=true)
  175.        *
  176.        * @var \DateTime
  177.        */
  178.       private $subSubCategoryIconFileUpdatedAt;
  180.       /**
  181.        * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  182.        * of 'UploadedFile' is injected into this setter to trigger the  update. If this
  183.        * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  184.        * must be able to accept an instance of 'File' as the bundle will inject one here
  185.        * during Doctrine hydration.
  186.        *
  187.        * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile $image
  188.        */
  189.       public function setSubSubCategoryIconFile(File $image = null) {
  190.           $this->subSubCategoryIconFile = $image;
  192.           if (null !== $image) {
  193.   // It is required that at least one field changes if you are using doctrine
  194.   // otherwise the event listeners won't be called and the file is lost
  195.               $this->subSubCategoryIconFileUpdatedAt = new \DateTimeImmutable();
  196.           }
  197.       }  public function getSubSubCategoryIconFile() {
  198.           return $this->subSubCategoryIconFile;
  199.       }
  200.        public function getSubSubCategoryIconFileName(): ?string
  201.       {
  202.           return $this->subSubCategoryIconFileName;
  203.       }
  205.       public function setSubSubCategoryIconFileName(?string $subSubCategoryIconFileName): self
  206.       {
  207.           $this->subSubCategoryIconFileName = $subSubCategoryIconFileName;
  209.           return $this;
  210.       }
  212.       public function getSubSubCategoryIconFileSize(): ?int
  213.       {
  214.           return $this->subSubCategoryIconFileSize;
  215.       }
  217.       public function setSubSubCategoryIconFileSize(?int $subSubCategoryIconFileSize): self
  218.       {
  219.           $this->subSubCategoryIconFileSize = $subSubCategoryIconFileSize;
  221.           return $this;
  222.       }
  224.       public function getSubSubCategoryIconFileUpdatedAt(): ?\DateTimeInterface
  225.       {
  226.           return $this->subSubCategoryIconFileUpdatedAt;
  227.       }
  229.       public function setSubSubCategoryIconFileUpdatedAt(?\DateTimeInterface $subSubCategoryIconFileUpdatedAt): self
  230.       {
  231.           $this->subSubCategoryIconFileUpdatedAt = $subSubCategoryIconFileUpdatedAt;
  233.           return $this;
  234.       }
  236.     /**
  237.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  238.      * @Vich\UploadableField(mapping="subSubCategory", fileNameProperty="subSubCategoryFileName", size="subSubCategoryFileSize")
  239.      * @Assert\File(
  240.      *     maxSize = "1200k"
  241.      * )
  242.      *
  243.      * @var File
  244.      */
  245.     private $subSubCategoryFile;
  247.     /**
  248.      * @ORM\Column(type="string", length=255, nullable=true)
  249.      *
  250.      * @var string
  251.      */
  252.     private $subSubCategoryFileName;
  254.     /**
  255.      * @ORM\Column(type="integer", nullable=true)
  256.      *
  257.      * @var integer
  258.      */
  259.     private $subSubCategoryFileSize;
  261.     /**
  262.      * @ORM\Column(type="datetime", nullable=true)
  263.      *
  264.      * @var \DateTime
  265.      */
  266.     private $subSubCategoryFileUpdatedAt;
  268.     /**
  269.      * @Gedmo\SortablePosition()
  270.      * @ORM\Column(type="integer", nullable=true)
  271.      */
  272.     private $position;
  274.     /**
  275.      * @ORM\OneToMany(targetEntity=SubSubSubCategory::class, mappedBy="subSubCategory")
  276.      */
  277.     private $subSubSubCategories;
  279.     /**
  280.      * @ORM\OneToMany(targetEntity=ApplicationProduct::class, mappedBy="subSubCategory")
  281.      */
  282.     private $applicationProducts;
  284.     /**
  285.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  286.      * of 'UploadedFile' is injected into this setter to trigger the  update. If this
  287.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  288.      * must be able to accept an instance of 'File' as the bundle will inject one here
  289.      * during Doctrine hydration.
  290.      *
  291.      * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile $image
  292.      */
  293.     public function setSubSubCategoryFile(File $image = null)
  294.     {
  295.         $this->subSubCategoryFile = $image;
  297.         if (null !== $image) {
  298.             // It is required that at least one field changes if you are using doctrine
  299.             // otherwise the event listeners won't be called and the file is lost
  300.             $this->subSubCategoryFileUpdatedAt = new \DateTimeImmutable();
  301.         }
  302.     }
  304.     public function getSubSubCategoryFile()
  305.     {
  306.         return $this->subSubCategoryFile;
  307.     }
  309.     public function getSubSubCategoryFileName(): ?string
  310.     {
  311.         return $this->subSubCategoryFileName;
  312.     }
  314.     public function setSubSubCategoryFileName(?string $subSubCategoryFileName): self
  315.     {
  316.         $this->subSubCategoryFileName = $subSubCategoryFileName;
  318.         return $this;
  319.     }
  321.     public function getSubSubCategoryFileSize(): ?int
  322.     {
  323.         return $this->subSubCategoryFileSize;
  324.     }
  326.     public function setSubSubCategoryFileSize(?int $subSubCategoryFileSize): self
  327.     {
  328.         $this->subSubCategoryFileSize = $subSubCategoryFileSize;
  330.         return $this;
  331.     }
  333.     public function getSubSubCategoryFileUpdatedAt(): ?\DateTimeInterface
  334.     {
  335.         return $this->subSubCategoryFileUpdatedAt;
  336.     }
  338.     public function setSubSubCategoryFileUpdatedAt(?\DateTimeInterface $subSubCategoryFileUpdatedAt): self
  339.     {
  340.         $this->subSubCategoryFileUpdatedAt = $subSubCategoryFileUpdatedAt;
  342.         return $this;
  343.     }
  345.     public function __construct()
  346.     {
  347.         $this->products = new ArrayCollection();
  348.         $this->subSubSubCategories = new ArrayCollection();
  349.         $this->applicationProducts = new ArrayCollection();
  350.     }
  352.     public function getId(): ?int
  353.     {
  354.         return $this->id;
  355.     }
  357.     public function getSubCategory(): ?SubCategory
  358.     {
  359.         return $this->subCategory;
  360.     }
  362.     public function setSubCategory(?SubCategory $subCategory): self
  363.     {
  364.         $this->subCategory = $subCategory;
  366.         return $this;
  367.     }
  369.     public function setParent(?SubCategory $category): self
  370.     {
  371.         return $this->setSubCategory($category);
  372.     }
  374.     public function getParent(): ?SubCategory
  375.     {
  376.         return $this->subCategory;
  377.     }
  379.     /**
  380.      * @return Collection<int, Product>
  381.      */
  382.     public function getProducts(): Collection
  383.     {
  384.         return $this->products;
  385.     }
  387.     public function addProduct(Product $product): self
  388.     {
  389.         if (!$this->products->contains($product)) {
  390.             $this->products[] = $product;
  391.             $product->setSubSubCategory($this);
  392.         }
  394.         return $this;
  395.     }
  397.     public function removeProduct(Product $product): self
  398.     {
  399.         if ($this->products->removeElement($product)) {
  400.             // set the owning side to null (unless already changed)
  401.             if ($product->getSubSubCategory() === $this) {
  402.                 $product->setSubSubCategory(null);
  403.             }
  404.         }
  406.         return $this;
  407.     }
  409.     public function getPosition(): ?int
  410.     {
  411.         return $this->position;
  412.     }
  414.     public function setPosition(?int $position): self
  415.     {
  416.         $this->position = $position;
  418.         return $this;
  419.     }
  421.     /**
  422.      * @return Collection<int, SubSubSubCategory>
  423.      */
  424.     public function getSubSubSubCategories(): Collection
  425.     {
  426.         return $this->subSubSubCategories;
  427.     }
  429.     public function addSubSubSubCategory(SubSubSubCategory $subSubSubCategory): self
  430.     {
  431.         if (!$this->subSubSubCategories->contains($subSubSubCategory)) {
  432.             $this->subSubSubCategories[] = $subSubSubCategory;
  433.             $subSubSubCategory->setSubSubCategory($this);
  434.         }
  436.         return $this;
  437.     }
  439.     public function removeSubSubSubCategory(SubSubSubCategory $subSubSubCategory): self
  440.     {
  441.         if ($this->subSubSubCategories->removeElement($subSubSubCategory)) {
  442.             // set the owning side to null (unless already changed)
  443.             if ($subSubSubCategory->getSubSubCategory() === $this) {
  444.                 $subSubSubCategory->setSubSubCategory(null);
  445.             }
  446.         }
  448.         return $this;
  449.     }
  452.     public function findChild($name, $locale = 'fr') : ?SubSubSubCategory
  453.     {
  454.         foreach ($this->subSubSubCategories as $child) {
  455.             if ($child->getTitle() === $name) {
  456.                 return $child;
  457.             }
  458.         }
  460.         return null;
  461.     }
  463.     public function addChild(SubSubSubCategory $child): self
  464.     {
  465.         return $this->addSubSubSubCategory($child);
  466.     }
  468.     /**
  469.      * @return Collection<int, ApplicationProduct>
  470.      */
  471.     public function getApplicationProducts(): Collection
  472.     {
  473.         return $this->applicationProducts;
  474.     }
  476.     public function addApplicationProduct(ApplicationProduct $applicationProduct): self
  477.     {
  478.         if (!$this->applicationProducts->contains($applicationProduct)) {
  479.             $this->applicationProducts[] = $applicationProduct;
  480.             $applicationProduct->setSubSubCategory($this);
  481.         }
  483.         return $this;
  484.     }
  486.     public function removeApplicationProduct(ApplicationProduct $applicationProduct): self
  487.     {
  488.         if ($this->applicationProducts->removeElement($applicationProduct)) {
  489.             if ($applicationProduct->getSubSubCategory() === $this) {
  490.                 $applicationProduct->setSubSubCategory(null);
  491.             }
  492.         }
  494.         return $this;
  495.     }
  496. }