src/Entity/Slider.php line 28

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use App\Repository\SliderRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use ApiPlatform\Metadata\ApiFilter;
  12. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
  13. use Symfony\Component\Serializer\Annotation\Groups;
  15. #[ORM\Entity(repositoryClass: SliderRepository::class)]
  16. #[ApiResource(
  17.     normalizationContext: ['groups' => ['slider:read']],
  18.     denormalizationContext: ['groups' => ['slider:write']],
  19.     order: ['id' => 'DESC'],
  20. )]
  21. #[ApiFilter(
  22.     SearchFilter::class, 
  23.     properties: [
  24.         'slug' => 'ipartial', 
  25.         'name' => 'ipartial', 
  26.     ]
  27. )]
  28. class Slider
  29. {
  30.     #[ORM\Id]
  31.     #[ORM\GeneratedValue]
  32.     #[ORM\Column]
  33.     #[Groups(['slider:read', 'slider:write', 'page:read', 'pageInfo:read'])]
  34.     private ?int $id = null;
  36.     #[ORM\Column(length: 255, nullable: true)]
  37.     #[Groups(['slider:read', 'slider:write', 'page:read', 'pageInfo:read'])]
  38.     private ?string $name = null;
  40.     #[ORM\Column(length: 100, nullable: true)]
  41.     #[Groups(['slider:read', 'slider:write', 'page:read', 'pageInfo:read'])]
  42.     private ?string $slug = null;
  44.     #[ORM\Column(type: Types::TEXT)]
  45.     #[Groups(['slider:read', 'slider:write', 'page:read', 'pageInfo:read'])]
  46.     private ?string $content = null;
  48.     #[ORM\OneToMany(mappedBy: 'slider', targetEntity: PageInfos::class)]
  49.     #[Groups(['slider:read', 'slider:write'])]
  50.     private Collection $pageInfos;
  52.     #[ORM\OneToMany(mappedBy: 'slider', targetEntity: Projects::class)]
  53.     #[Groups(['slider:read', 'slider:write'])]
  54.     private Collection $projects;
  56.     #[ORM\OneToMany(mappedBy: 'slider', targetEntity: Slide::class)]
  57.     #[Groups(['slider:read', 'slider:write', 'page:read', 'pageInfo:read'])]
  58.     private Collection $slides;
  60.     #[ORM\OneToMany(mappedBy: 'slider', targetEntity: Pages::class)]
  61.     private Collection $pages;
  63.     #[Groups(['slider:read', 'slider:write', 'page:read', 'pageInfo:read'])]
  64.     #[ORM\ManyToOne(inversedBy: 'sliders')]
  65.     private ?Languages $language = null;
  67.     #[Groups(['slider:read', 'slider:write', 'page:read', 'pageInfo:read'])]
  68.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'translations')]
  69.     private ?self $translation = null;
  71.     /**
  72.      * @var Collection<int, self>
  73.      */
  74.     #[Groups(['slider:read', 'slider:write', 'page:read', 'pageInfo:read'])]
  75.     #[ORM\OneToMany(mappedBy: 'translation', targetEntity: self::class)]
  76.     private Collection $translations;
  78.     public function __construct()
  79.     {
  80.         $this->pageInfos = new ArrayCollection();
  81.         $this->projects = new ArrayCollection();
  82.         $this->slides = new ArrayCollection();
  83.         $this->pages = new ArrayCollection();
  84.         $this->translations = new ArrayCollection();
  85.     }
  87.     public function getId(): ?int
  88.     {
  89.         return $this->id;
  90.     }
  92.     public function getName(): ?string
  93.     {
  94.         return $this->name;
  95.     }
  97.     public function setName(?string $name): static
  98.     {
  99.         $this->name = $name;
  101.         return $this;
  102.     }
  104.     public function getSlug(): ?string
  105.     {
  106.         return $this->slug;
  107.     }
  109.     public function setSlug(?string $slug): static
  110.     {
  111.         $this->slug = $slug;
  113.         return $this;
  114.     }
  116.     public function getContent(): ?string
  117.     {
  118.         return $this->content;
  119.     }
  121.     public function setContent(string $content): static
  122.     {
  123.         $this->content = $content;
  125.         return $this;
  126.     }
  128.     /**
  129.      * @return Collection<int, PageInfos>
  130.      */
  131.     public function getPageInfos(): Collection
  132.     {
  133.         return $this->pageInfos;
  134.     }
  136.     public function addPageInfo(PageInfos $pageInfo): static
  137.     {
  138.         if (!$this->pageInfos->contains($pageInfo)) {
  139.             $this->pageInfos->add($pageInfo);
  140.             $pageInfo->setSlider($this);
  141.         }
  143.         return $this;
  144.     }
  146.     public function removePageInfo(PageInfos $pageInfo): static
  147.     {
  148.         if ($this->pageInfos->removeElement($pageInfo)) {
  149.             // set the owning side to null (unless already changed)
  150.             if ($pageInfo->getSlider() === $this) {
  151.                 $pageInfo->setSlider(null);
  152.             }
  153.         }
  155.         return $this;
  156.     }
  158.     /**
  159.      * @return Collection<int, Projects>
  160.      */
  161.     public function getProjects(): Collection
  162.     {
  163.         return $this->projects;
  164.     }
  166.     public function addProject(Projects $project): static
  167.     {
  168.         if (!$this->projects->contains($project)) {
  169.             $this->projects->add($project);
  170.             $project->setSlider($this);
  171.         }
  173.         return $this;
  174.     }
  176.     public function removeProject(Projects $project): static
  177.     {
  178.         if ($this->projects->removeElement($project)) {
  179.             // set the owning side to null (unless already changed)
  180.             if ($project->getSlider() === $this) {
  181.                 $project->setSlider(null);
  182.             }
  183.         }
  185.         return $this;
  186.     }
  188.     /**
  189.      * @return Collection<int, Slide>
  190.      */
  191.     public function getSlides(): Collection
  192.     {
  193.         return $this->slides;
  194.     }
  196.     public function addSlide(Slide $slide): static
  197.     {
  198.         if (!$this->slides->contains($slide)) {
  199.             $this->slides->add($slide);
  200.             $slide->setSlider($this);
  201.         }
  203.         return $this;
  204.     }
  206.     public function removeSlide(Slide $slide): static
  207.     {
  208.         if ($this->slides->removeElement($slide)) {
  209.             // set the owning side to null (unless already changed)
  210.             if ($slide->getSlider() === $this) {
  211.                 $slide->setSlider(null);
  212.             }
  213.         }
  215.         return $this;
  216.     }
  218.     /**
  219.      * @return Collection<int, Pages>
  220.      */
  221.     public function getPages(): Collection
  222.     {
  223.         return $this->pages;
  224.     }
  226.     public function addPage(Pages $page): static
  227.     {
  228.         if (!$this->pages->contains($page)) {
  229.             $this->pages->add($page);
  230.             $page->setSlider($this);
  231.         }
  233.         return $this;
  234.     }
  236.     public function removePage(Pages $page): static
  237.     {
  238.         if ($this->pages->removeElement($page)) {
  239.             // set the owning side to null (unless already changed)
  240.             if ($page->getSlider() === $this) {
  241.                 $page->setSlider(null);
  242.             }
  243.         }
  245.         return $this;
  246.     }
  248.     public function getLanguage(): ?Languages
  249.     {
  250.         return $this->language;
  251.     }
  253.     public function setLanguage(?Languages $language): static
  254.     {
  255.         $this->language = $language;
  257.         return $this;
  258.     }
  260.     public function getTranslation(): ?self
  261.     {
  262.         return $this->translation;
  263.     }
  265.     public function setTranslation(?self $translation): static
  266.     {
  267.         $this->translation = $translation;
  269.         return $this;
  270.     }
  272.     /**
  273.      * @return Collection<int, self>
  274.      */
  275.     public function getTranslations(): Collection
  276.     {
  277.         return $this->translations;
  278.     }
  280.     public function addTranslation(self $translation): static
  281.     {
  282.         if (!$this->translations->contains($translation)) {
  283.             $this->translations->add($translation);
  284.             $translation->setTranslation($this);
  285.         }
  287.         return $this;
  288.     }
  290.     public function removeTranslation(self $translation): static
  291.     {
  292.         if ($this->translations->removeElement($translation)) {
  293.             // set the owning side to null (unless already changed)
  294.             if ($translation->getTranslation() === $this) {
  295.                 $translation->setTranslation(null);
  296.             }
  297.         }
  299.         return $this;
  300.     }
  301. }