src/Entity/Media.php line 70

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
  6. use ApiPlatform\Metadata\ApiFilter;
  7. use ApiPlatform\Metadata\ApiResource;
  8. use ApiPlatform\Metadata\Delete;
  9. use ApiPlatform\Metadata\GetCollection;
  10. use ApiPlatform\Metadata\Post;
  11. use ApiPlatform\OpenApi\Model\Operation;
  12. use ApiPlatform\OpenApi\Model\RequestBody;
  13. use App\Controller\MediaController;
  14. use App\Controller\MediaDeleteController;
  15. use App\Controller\MediaGetController;
  16. use App\Controller\ProjectsController;
  17. use App\Entity\Traits\CreatedAtTrait;
  18. use App\Entity\Traits\UpdatedAtTrait;
  19. use App\Repository\MediaRepository;
  20. use Doctrine\ORM\Mapping as ORM;
  21. use Liip\ImagineBundle\Imagine\Cache\CacheManager;
  22. use Symfony\Component\Filesystem\Filesystem;
  23. use Symfony\Component\HttpFoundation\File\File;
  24. use Symfony\Component\Serializer\Annotation\Groups;
  25. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  27. #[ORM\HasLifecycleCallbacks]
  28. #[Vich\Uploadable]
  29. #[ORM\Entity(repositoryClass: MediaRepository::class)]
  30. #[ApiResource(
  31.     operations: [
  32.         new GetCollection(
  33.             uriTemplate: '/user/medias',
  34.             controller: MediaGetController::class,
  35.             normalizationContext: ['groups' => ['media:read']],
  36.             security: "is_granted('ROLE_USER')"
  37.         ),
  38.         new Post(
  39.             uriTemplate: '/user/medias',
  40.             controller: MediaController::class,
  41.             openapi: new Operation(
  42.                 requestBody: new RequestBody(
  43.                     content: new \ArrayObject([
  44.                         'multipart/form-data' => [
  45.                             'schema' => [
  46.                                 'type' => 'object',
  47.                                 'properties' => [
  48.                                     'mediaFile' => [
  49.                                         'type' => 'string',
  50.                                         'format' => 'binary'
  51.                                     ]
  52.                                 ]
  53.                             ]
  54.                         ]
  55.                     ])
  56.                 )
  57.             ),
  58.             security: "is_granted('ROLE_USER')",
  59.             deserialize: false,
  60.         ),
  61.         new Delete(
  62.             uriTemplate: '/user/medias/{id}',
  63.             controller: MediaDeleteController::class,
  64.             security: "is_granted('ROLE_USER')"
  65.         )
  66.     ],
  67.     normalizationContext: ['groups' => 'media:read'],
  68. )]
  69. #[ApiFilter(SearchFilter::class, properties: ['mimeType' => 'partial'])]
  70. class Media
  71. {
  72.     use CreatedAtTrait;
  73.     use UpdatedAtTrait;
  75.     #[ORM\Id]
  76.     #[ORM\GeneratedValue]
  77.     #[ORM\Column]
  78.     #[Groups(['media:read'])]
  79.     private ?int $id = null;
  81.     #[ORM\Column(length: 255, nullable: true)]
  82.     #[Groups(['media:read'])]
  83.     private ?string $mimeType = null;
  85.     #[Vich\UploadableField(mapping: 'media_file', fileNameProperty: 'media')]
  86.     private ?File $mediaFile = null;
  88.     #[ORM\Column(length: 255, nullable: true)]
  89.     #[Groups(['media:read'])]
  90.     private ?string $media = null;
  92.     #[ORM\Column(length: 255)]
  93.     #[Groups(['media:read'])]
  94.     private ?string $fileName = null;
  96.     #[ORM\ManyToOne(inversedBy: 'media')]
  97.     private ?Directories $directory = null;
  99.     #[ORM\ManyToOne(inversedBy: 'medias')]
  100.     private ?Client $client = null;
  102.     public function getId(): ?int
  103.     {
  104.         return $this->id;
  105.     }
  107.     public function getMimeType(): ?string
  108.     {
  109.         return $this->mimeType;
  110.     }
  112.     public function setMimeType(string $mimeType): static
  113.     {
  114.         $this->mimeType = $mimeType;
  116.         return $this;
  117.     }
  119.     public function getMedia(): ?string
  120.     {
  121.         return $this->media;
  122.     }
  124.     public function setMedia(?string $media): self
  125.     {
  126.         $this->media = $media;
  128.         return $this;
  129.     }
  131.     public function getMediaFile(): ?File
  132.     {
  133.         return $this->mediaFile;
  134.     }
  136.     public function setMediaFile(?File $mediaFile): void
  137.     {
  138.         $this->mediaFile = $mediaFile;
  139.         if (null !== $mediaFile) {
  140.             $this->updatedAt = new \DateTime();
  141.         }
  142.     }
  144.     public function getFileName(): ?string
  145.     {
  146.         return $this->fileName;
  147.     }
  149.     public function setFileName(string $fileName): static
  150.     {
  151.         $this->fileName = $fileName;
  153.         return $this;
  154.     }
  156.     public function getThumbnail(CacheManager $cacheManager, string $filter): ?string
  157.     {
  158.         if (null === $this->media || str_contains($this->mimeType, 'audio')) {
  159.             return null;
  160.         }
  162.         $path = '/media/' . $this->media;
  164.         if (!str_contains($this->mimeType, 'image')) {
  165.             $path = '/media/' . explode('.', $this->media)[0] . '.jpg';
  166.         }
  168.         return parse_url($cacheManager->getBrowserPath($path, $filter))['path'];
  169.     }
  171.     #[Orm\PreRemove]
  172.     public function removeMedia(): void
  173.     {
  174.         if (!str_contains($this->mimeType, 'image')) {
  175.             $filesystem = new Filesystem();
  176.             $path = 'media/' . explode('.', $this->media)[0] . '.jpg';
  177.             $cachePath = 'media/cache/thumb_300x300/media/' . explode('.', $this->media)[0] . '.jpg';
  179.             if ($filesystem->exists($path)) {
  180.                 $filesystem->remove($path);
  181.             }
  183.             if ($filesystem->exists($cachePath)) {
  184.                 $filesystem->remove($cachePath);
  185.             }
  186.         }
  187.     }
  189.     public function getDirectory(): ?Directories
  190.     {
  191.         return $this->directory;
  192.     }
  194.     public function setDirectory(?Directories $directory): static
  195.     {
  196.         $this->directory = $directory;
  198.         return $this;
  199.     }
  201.     public function getClient(): ?Client
  202.     {
  203.         return $this->client;
  204.     }
  206.     public function setClient(?Client $client): static
  207.     {
  208.         $this->client = $client;
  210.         return $this;
  211.     }
  212. }