src/Entity/MediaObject.php line 53

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiProperty;
  6. use ApiPlatform\Metadata\ApiResource;
  7. use ApiPlatform\Metadata\Get;
  8. use ApiPlatform\Metadata\GetCollection;
  9. use ApiPlatform\Metadata\Post;
  10. use App\Controller\CreateMediaObjectAction;
  11. use App\Repository\MediaObjectRepository;
  12. use Doctrine\Common\Collections\ArrayCollection;
  13. use Doctrine\Common\Collections\Collection;
  14. use Doctrine\DBAL\Types\Types;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use Symfony\Component\Serializer\Annotation\Groups;
  17. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  18. use Symfony\Component\Validator\Constraints as Assert;
  19. use ApiPlatform\OpenApi\Model;
  20. use Symfony\Component\HttpFoundation\File\File;
  22. #[ORM\Entity(repositoryClass: MediaObjectRepository::class)]
  23. #[ApiResource(
  24.     types: ['https://schema.org/MediaObject'],
  25.     operations: [
  26.         new Get(),
  27.         new GetCollection(),
  28.         new Post(
  29.             controller: CreateMediaObjectAction::class,
  30.             openapi: new Model\Operation(
  31.                 requestBody: new Model\RequestBody(
  32.                     content: new \ArrayObject([
  33.                         'multipart/form-data' => [
  34.                             'schema' => [
  35.                                 'type' => 'object',
  36.                                 'properties' => [
  37.                                     'file' => [
  38.                                         'type' => 'string',
  39.                                         'format' => 'binary'
  40.                                     ]
  41.                                 ]
  42.                             ]
  43.                         ]
  44.                     ])
  45.                 )
  46.             ),
  47.             validationContext: ['groups' => ['Default', 'media_object_create']],
  48.             deserialize: false
  49.         )
  50.     ],
  51.     normalizationContext: ['groups' => ['media_object:read']]
  52. )]
  53. class MediaObject
  54. {
  55.     #[ORM\Id]
  56.     #[ORM\GeneratedValue]
  57.     #[ORM\Column]
  58.     private ?int $id = null;
  60.     #[ApiProperty(types: ['https://schema.org/contentUrl'])]
  61.     #[Groups(['media_object:read'])]
  62.     public ?string $contentUrl = null;
  64.     #[Vich\UploadableField(mapping: "media_object", fileNameProperty: "filePath")]
  65.     #[Assert\NotNull(groups: ['media_object_create'])]
  66.     public ?File $file = null;
  69.     #[ORM\Column(length: 255)]
  70.     #[Groups(['media_object:read', 'media_object_create'])]
  71.     private ?string $name = '';
  73.     #[ORM\Column(type: Types::TEXT)]
  74.     private ?string $filePath = '';
  76.     #[ORM\OneToMany(mappedBy: 'mainImage', targetEntity: Course::class)]
  77.     private Collection $courses;
  79.     #[ORM\ManyToMany(targetEntity: Lesson::class, mappedBy: 'assets')]
  80.     private Collection $lessons;
  82.     #[ORM\OneToMany(mappedBy: 'video', targetEntity: HealthInfoVideo::class)]
  83.     private Collection $healthInfoVideos;
  85.     #[ORM\OneToMany(mappedBy: 'video', targetEntity: BreakRoomVideo::class)]
  86.     private Collection $breakRoomVideos;
  88.     #[ORM\OneToMany(mappedBy: 'icon', targetEntity: Badge::class)]
  89.     private Collection $badges;
  91.     #[ORM\OneToMany(mappedBy: 'articulate', targetEntity: Lesson::class)]
  92.     private Collection $articulateLesson;
  94.     #[ORM\OneToMany(mappedBy: 'image', targetEntity: LandingpageElement::class)]
  95.     private Collection $landingpageElements;
  97.     public function __construct()
  98.     {
  99.         $this->courses = new ArrayCollection();
  100.         $this->lessons = new ArrayCollection();
  101.         $this->healthInfoVideos = new ArrayCollection();
  102.         $this->breakRoomVideos = new ArrayCollection();
  103.         $this->badges = new ArrayCollection();
  104.         $this->filePath = '';
  105.         $this->articulateLesson = new ArrayCollection();
  106.         $this->landingpageElements = new ArrayCollection();
  107.     }
  109.     public function getId(): ?int
  110.     {
  111.         return $this->id;
  112.     }
  114.     public function __toString(): string
  115.     {
  116.         return $this->name;
  118.     }
  120.     public function getName(): ?string
  121.     {
  122.         return $this->name;
  123.     }
  125.     public function setName(string $name): self
  126.     {
  127.         $this->name = $name;
  129.         return $this;
  130.     }
  132.     public function getFilePath(): ?string
  133.     {
  134.         return $this->filePath;
  135.     }
  137.     public function setFilePath(?string $filePath): self
  138.     {
  139.         if (!is_null($filePath)) {
  140.             $this->filePath = $filePath;
  142.         }
  144.         return $this;
  145.     }
  147.     /**
  148.      * @return Collection<int, Course>
  149.      */
  150.     public function getCourses(): Collection
  151.     {
  152.         return $this->courses;
  153.     }
  155.     public function addCourse(Course $course): self
  156.     {
  157.         if (!$this->courses->contains($course)) {
  158.             $this->courses->add($course);
  159.             $course->setMainImage($this);
  160.         }
  162.         return $this;
  163.     }
  165.     public function removeCourse(Course $course): self
  166.     {
  167.         if ($this->courses->removeElement($course)) {
  168.             // set the owning side to null (unless already changed)
  169.             if ($course->getMainImage() === $this) {
  170.                 $course->setMainImage(null);
  171.             }
  172.         }
  174.         return $this;
  175.     }
  177.     /**
  178.      * @return Collection<int, Lesson>
  179.      */
  180.     public function getLessons(): Collection
  181.     {
  182.         return $this->lessons;
  183.     }
  185.     public function addLesson(Lesson $lesson): self
  186.     {
  187.         if (!$this->lessons->contains($lesson)) {
  188.             $this->lessons->add($lesson);
  189.             $lesson->addAsset($this);
  190.         }
  192.         return $this;
  193.     }
  195.     public function removeLesson(Lesson $lesson): self
  196.     {
  197.         if ($this->lessons->removeElement($lesson)) {
  198.             $lesson->removeAsset($this);
  199.         }
  201.         return $this;
  202.     }
  204.     /**
  205.      * @return Collection<int, HealthInfoVideo>
  206.      */
  207.     public function getHealthInfoVideos(): Collection
  208.     {
  209.         return $this->healthInfoVideos;
  210.     }
  212.     public function addHealthInfoVideo(HealthInfoVideo $healthInfoVideo): self
  213.     {
  214.         if (!$this->healthInfoVideos->contains($healthInfoVideo)) {
  215.             $this->healthInfoVideos->add($healthInfoVideo);
  216.             $healthInfoVideo->setVideo($this);
  217.         }
  219.         return $this;
  220.     }
  222.     public function removeHealthInfoVideo(HealthInfoVideo $healthInfoVideo): self
  223.     {
  224.         if ($this->healthInfoVideos->removeElement($healthInfoVideo)) {
  225.             // set the owning side to null (unless already changed)
  226.             if ($healthInfoVideo->getVideo() === $this) {
  227.                 $healthInfoVideo->setVideo(null);
  228.             }
  229.         }
  231.         return $this;
  232.     }
  234.     /**
  235.      * @return Collection<int, BreakRoomVideo>
  236.      */
  237.     public function getBreakRoomVideos(): Collection
  238.     {
  239.         return $this->breakRoomVideos;
  240.     }
  242.     public function addBreakRoomVideo(BreakRoomVideo $breakRoomVideo): self
  243.     {
  244.         if (!$this->breakRoomVideos->contains($breakRoomVideo)) {
  245.             $this->breakRoomVideos->add($breakRoomVideo);
  246.             $breakRoomVideo->setVideo($this);
  247.         }
  249.         return $this;
  250.     }
  252.     public function removeBreakRoomVideo(BreakRoomVideo $breakRoomVideo): self
  253.     {
  254.         if ($this->breakRoomVideos->removeElement($breakRoomVideo)) {
  255.             // set the owning side to null (unless already changed)
  256.             if ($breakRoomVideo->getVideo() === $this) {
  257.                 $breakRoomVideo->setVideo(null);
  258.             }
  259.         }
  261.         return $this;
  262.     }
  264.     /**
  265.      * @return Collection<int, Badge>
  266.      */
  267.     public function getBadges(): Collection
  268.     {
  269.         return $this->badges;
  270.     }
  272.     public function addBadge(Badge $badge): self
  273.     {
  274.         if (!$this->badges->contains($badge)) {
  275.             $this->badges->add($badge);
  276.             $badge->setIcon($this);
  277.         }
  279.         return $this;
  280.     }
  282.     public function removeBadge(Badge $badge): self
  283.     {
  284.         if ($this->badges->removeElement($badge)) {
  285.             // set the owning side to null (unless already changed)
  286.             if ($badge->getIcon() === $this) {
  287.                 $badge->setIcon(null);
  288.             }
  289.         }
  291.         return $this;
  292.     }
  294.     /**
  295.      * @return Collection<int, Lesson>
  296.      */
  297.     public function getArticulateLesson(): Collection
  298.     {
  299.         return $this->articulateLesson;
  300.     }
  302.     public function addArticulateLesson(Lesson $articulateLesson): self
  303.     {
  304.         if (!$this->articulateLesson->contains($articulateLesson)) {
  305.             $this->articulateLesson->add($articulateLesson);
  306.             $articulateLesson->setArticulate($this);
  307.         }
  309.         return $this;
  310.     }
  312.     public function removeArticulateLesson(Lesson $articulateLesson): self
  313.     {
  314.         if ($this->articulateLesson->removeElement($articulateLesson)) {
  315.             // set the owning side to null (unless already changed)
  316.             if ($articulateLesson->getArticulate() === $this) {
  317.                 $articulateLesson->setArticulate(null);
  318.             }
  319.         }
  321.         return $this;
  322.     }
  324.     /**
  325.      * @return Collection<int, LandingpageElement>
  326.      */
  327.     public function getLandingpageElements(): Collection
  328.     {
  329.         return $this->landingpageElements;
  330.     }
  332.     public function addLandingpageElement(LandingpageElement $landingpageElement): self
  333.     {
  334.         if (!$this->landingpageElements->contains($landingpageElement)) {
  335.             $this->landingpageElements->add($landingpageElement);
  336.             $landingpageElement->setImage($this);
  337.         }
  339.         return $this;
  340.     }
  342.     public function removeLandingpageElement(LandingpageElement $landingpageElement): self
  343.     {
  344.         if ($this->landingpageElements->removeElement($landingpageElement)) {
  345.             // set the owning side to null (unless already changed)
  346.             if ($landingpageElement->getImage() === $this) {
  347.                 $landingpageElement->setImage(null);
  348.             }
  349.         }
  351.         return $this;
  352.     }
  353. }