Symfony Profiler

<?php
namespace App\Entity;
use App\Repository\MediaRepository;
use Doctrine\ORM\Mapping as ORM;
use Gedmo\Blameable\Traits\BlameableEntity;
use Gedmo\Timestampable\Traits\TimestampableEntity;
use Symfony\Component\HttpFoundation\File\File;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\Serializer\Annotation\Groups;
use Symfony\Component\Validator\Constraints as Assert;
use Vich\UploaderBundle\Mapping\Annotation as Vich;
use Symfony\Component\Mime\MimeTypes;
#[ORM\Entity(repositoryClass: MediaRepository::class)]
#[Vich\Uploadable]
class Media
{
use TimestampableEntity; //Hook timestampable behavior. Updates createdAt, updatedAt fields
use BlameableEntity; //Hook blameable behavior. Updates createdBy, updatedBy fields
public static function getImageMimetypes($restrictive = false): array
{
$mimeTypes = new MimeTypes();
$imageMimetypes = [];
array_push($imageMimetypes, ...$mimeTypes->getMimeTypes('jpg'));
array_push($imageMimetypes, ...$mimeTypes->getMimeTypes('png'));
if(!$restrictive) {
array_push($imageMimetypes, ...$mimeTypes->getMimeTypes('svg'));
array_push($imageMimetypes, ...$mimeTypes->getMimeTypes('gif'));
array_push($imageMimetypes, ...$mimeTypes->getMimeTypes('webp'));
array_push($imageMimetypes, ...$mimeTypes->getMimeTypes('bmp'));
array_push($imageMimetypes, ...$mimeTypes->getMimeTypes('tiff'));
array_push($imageMimetypes, ...$mimeTypes->getMimeTypes('ico'));
}
return $imageMimetypes;
}
public static function getVideMimetypes($restrictive = false): array
{
$mimeTypes = new MimeTypes();
$videoMimetypes = [];
array_push($videoMimetypes, ...$mimeTypes->getMimeTypes('mp4'));
if(!$restrictive) {
array_push($videoMimetypes, ...$mimeTypes->getMimeTypes('webm'));
array_push($videoMimetypes, ...$mimeTypes->getMimeTypes('avi'));
array_push($videoMimetypes, ...$mimeTypes->getMimeTypes('mpeg'));
array_push($videoMimetypes, ...$mimeTypes->getMimeTypes('ogv'));
array_push($videoMimetypes, ...$mimeTypes->getMimeTypes('3gp'));
array_push($videoMimetypes, ...$mimeTypes->getMimeTypes('3g2'));
array_push($videoMimetypes, ...$mimeTypes->getMimeTypes('quicktime'));
}
return $videoMimetypes;
}
#[ORM\Id]
#[ORM\GeneratedValue(strategy: "IDENTITY")]
#[ORM\Column]
#[Groups(["media:read"])]
private ?int $id = null;
/**
* Fichero
* NOTE: This is not a mapped field of entity metadata, just a simple property.
*
* @var \Symfony\Component\HttpFoundation\File\File|UploadedFile|null $file
*/
#[Vich\UploadableField(
mapping: 'uploads',
fileNameProperty: 'filename',
size: 'size',
mimeType: 'mimeType',
originalName: 'originalName'
)]
private $file = null;
/**
* Ruta del Fichero donde se almacena la foto
*
* @var string|null
*/
#[ORM\Column(length: 255, nullable: true)]
#[Assert\Length(max: 255)]
#[Groups(["media:read"])]
private ?string $filename = null;
/**
* File Size in BYTES
*/
#[ORM\Column(type: 'integer')]
private ?int $size = null;
/**
* Tipo de fichero MIME
*
* @var string|null
*/
#[ORM\Column(length: 20, nullable: true)]
#[Assert\Length(max: 20)]
#[Groups(["media:read"])]
private ?string $mimetype = null;
/**
* Nombre de la foto
*
* @var string|null
*/
#[ORM\Column(length: 255, nullable: true)]
#[Assert\Length(max: 255)]
#[Groups(["media:read"])]
private ?string $originalName = null;
#[ORM\ManyToOne(inversedBy: 'productImages')]
private ?Product $productImage = null;
#[ORM\ManyToOne(inversedBy: 'productVideos')]
private ?Product $productVideo = null;
#[ORM\OneToOne(mappedBy: 'avatar', cascade: ['persist', 'remove'])]
private ?User $user = null;
#[ORM\Column]
#[Groups(["media:read"])]
private ?int $position = 0;
#[ORM\Column(length: 255)]
private ?string $directory = "";
#[ORM\ManyToOne(inversedBy: 'media')]
private ?Producer $producer = null;
#[ORM\ManyToOne(inversedBy: 'media')]
private ?Brand $brand = null;
#[ORM\Column(nullable: true)]
private ?bool $active = false;
public function __toString()
{
return $this->filename;
}
/**
* Necesario para evitar el error: "Serialization of 'Symfony\Component\HttpFoundation\File\File' is not allowed
*
* @return void
*/
public function __serialize()
{
return [
$this->id,
$this->filename,
];
}
public function __unserialize(array $serialized)
{
list (
$this->id,
$this->filename,
) = $serialized;
}
public function getId(): ?int
{
return $this->id;
}
public function getFile(): ?File
{
return $this->file;
}
/**
* If manually uploading a file (i.e. not using Symfony Form) ensure an instance
* of 'UploadedFile' is injected into this setter to trigger the update. If this
* bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
* must be able to accept an instance of 'File' as the bundle will inject one here
* during Doctrine hydration.
*
* @param File|UploadedFile|null $file
*/
public function setFile(?File $file = null)
{
$this->file = $file;
// VERY IMPORTANT:
// It is required that at least one field changes if you are using Doctrine,
// otherwise the event listeners won't be called and the file is lost
if ($file) {
// if 'updatedAt' is not defined in your entity, use another property
$this->updatedAt = new \DateTime('now');
}
}
public function getFilename(): ?string
{
return $this->filename;
}
public function setFilename(?string $filename): self
{
$this->filename = $filename;
return $this;
}
/**
* In Bytes
*
* @return integer|null
*/
public function getSize(): ?int
{
return $this->size;
}
/**
* In KiloBytes
*
* @return int|null
*/
public function getSizeInKb(): ?int
{
return ceil($this->size / 1024.0);
}
/**
* In MegaBytes
*
* @return int|null
*/
public function getSizeInMb(): ?int
{
return ceil($this->size / 1024.0 / 1024.0);
}
public function setSize(?int $size): void
{
$this->size = $size;
}
public function getMimetype(): ?string
{
return $this->mimetype;
}
public function setMimetype(?string $mimetype): self
{
$this->mimetype = $mimetype;
return $this;
}
public function getOriginalName(): ?string
{
return $this->originalName;
}
public function setOriginalName(?string $originalName): self
{
$this->originalName = $originalName;
return $this;
}
public function getProductImage(): ?Product
{
return $this->productImage;
}
public function setProductImage(?Product $productImage): self
{
$this->productImage = $productImage;
return $this;
}
public function getProductVideo(): ?Product
{
return $this->productVideo;
}
public function setProductVideo(?Product $productVideo): self
{
$this->productVideo = $productVideo;
return $this;
}
public function getUser(): ?User
{
return $this->user;
}
public function setUser(?User $user): self
{
// unset the owning side of the relation if necessary
if ($user === null && $this->user !== null) {
$this->user->setAvatar(null);
}
// set the owning side of the relation if necessary
if ($user !== null && $user->getAvatar() !== $this) {
$user->setAvatar($this);
}
$this->user = $user;
return $this;
}
public function getPosition(): ?int
{
return $this->position;
}
public function setPosition(int $position): self
{
$this->position = $position;
return $this;
}
public function getDirectory(): ?string
{
return $this->directory;
}
public function setDirectory(?string $directory): self
{
$this->directory = $directory;
return $this;
}
public function getProducer(): ?Producer
{
return $this->producer;
}
public function setProducer(?Producer $producer): self
{
$this->producer = $producer;
return $this;
}
public function getBrand(): ?Brand
{
return $this->brand;
}
public function setBrand(?Brand $brand): self
{
$this->brand = $brand;
return $this;
}
public function isImage(): bool
{
return in_array($this->getMimetype(), self::getImageMimetypes());
}
public function isVideo(): bool
{
return in_array($this->getMimetype(), self::getVideMimetypes());
}
public function isActive(): ?bool
{
return $this->active;
}
public function setActive(bool $active): self
{
$this->active = $active;
return $this;
}
public function clone(self $media, string $dir, int $position): self
{
$fs = new \Symfony\Component\Filesystem\Filesystem();
$newFilename = pathinfo($media->getOriginalName(), PATHINFO_FILENAME) . '-' . time() . '.' . pathinfo($media->getOriginalName(), PATHINFO_EXTENSION);
$origin = __DIR__ . '/../../' . "uploads/{$dir}/{$media->getFilename()}";
$destination = __DIR__ . '/../../' . "uploads/{$dir}/{$newFilename}";
if ($fs->exists($origin)) {
$fs->copy($origin, $destination);
}
$this->setFilename($newFilename);
$this->setSize($media->getSize());
$this->setMimetype($media->getMimetype());
$this->setOriginalName($media->getOriginalName());
$this->setDirectory($media->getDirectory());
$this->setPosition($position);
$this->setActive(true);
return $this;
}
}

src/Entity/Media.php line 18