PiedWeb\CMSBundle\Entity\MediaTrait

Complexity

Total Complexity

70

Size/Duplication

Total Lines	434
Duplicated Lines	0 %

Test Coverage

Coverage

8.04%

Importance

Changes	2
Bugs	0	Features	0

44 Methods

Rating	Name	Duplication	Size	Complexity
A	setMediaFile()	0	6	2
A	removeMainImageFromPages()	0	4	2
A	setMimeType()	0	5	1
A	getFullPathWebP()	0	5	3
A	getMimeType()	0	3	1
A	getPageHasMedias()	0	3	1
A	setMainColor()	0	5	1
A	getExtension()	0	3	1
A	getMainImagePages()	0	3	1
A	getSlug()	0	13	3
A	setName()	0	5	1
A	setMediaBeforeUpdate()	0	5	1
A	setMedia()	0	14	3
A	getNameByLocale()	0	5	1
A	getMedia()	0	3	1
A	getHeight()	0	3	1
A	__toString()	0	3	1
A	setNames()	0	5	1
A	setSlug()	0	17	3
A	validate()	0	8	4
A	getName()	0	7	4
A	getMediaFile()	0	3	1
A	getSize()	0	3	1
A	getNames()	0	3	3
A	getDimensions()	0	3	1
A	getRelativeDir()	0	3	1
A	getPreviousMimeType()	0	3	1
A	setRelativeDir()	0	5	1
A	removePageHasMedia()	0	3	1
A	setDimensions()	0	11	3
A	addPageHasMedia()	0	4	1
A	getMainColorOpposite()	0	7	2
A	slugifyPreservingExtension()	0	6	1
A	getFullPath()	0	5	3
A	getMediaBeforeUpdate()	0	3	1
A	getPath()	0	3	1
A	setSize()	0	5	1
A	removeExtension()	0	3	1
A	setPageHasMedias()	0	5	2
A	getMainColor()	0	3	1
A	setSlugForce()	0	13	3
A	getSlugForce()	0	3	1
A	getWidth()	0	3	1
A	getRatio()	0	3	1

<?php

namespace PiedWeb\CMSBundle\Entity;

use Cocur\Slugify\Slugify;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\Mapping as ORM;
use InvertColor\Color;
use Symfony\Component\HttpFoundation\File\File;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Context\ExecutionContextInterface;
use Symfony\Component\Yaml\Yaml;
use Vich\UploaderBundle\Mapping\Annotation as Vich;

trait MediaTrait
{
    use TimestampableTrait;

    /**
     * @ORM\Column(type="string", length=50)
     */
    protected $mimeType;

    /**
     * @ORM\Column(type="string", length=255)
     */
    protected $relativeDir;

    /**
     * @ORM\Column(type="integer")
     */
    protected $size;

    /**
     * @ORM\Column(type="integer", nullable=true)
     */
    protected $height;

    /**
     * @ORM\Column(type="integer", nullable=true)
     */
    protected $width;

    /**
     * @ORM\Column(type="string", nullable=true)
     */
    protected $mainColor;

    /**
     * @ORM\Column(type="string", length=255)
     */
    protected $media;

    /**
     * NOTE : this is used only for media renaming.
     *
     * @var string
     */
    protected $mediaBeforeUpdate;

    /**
     * NOTE: This is not a mapped field of entity metadata, just a simple property.
     *
     * @Vich\UploadableField(
     *     mapping="media_media",
     *     fileNameProperty="slug",
     *     mimeType="mimeType",
     *     size="size",
     *     dimensions="dimensions"
     * )
     *
     * @var File
     */
    protected $mediaFile;

    /**
     * @ORM\Column(type="string", length=100, unique=true)
     */
    protected $name;

    /**
     * @ORM\Column(type="text", nullable=true)
     */
    protected $names;

    protected $slug;

    /**
     * @ORM\OneToMany(
     *     targetEntity="PiedWeb\CMSBundle\Entity\PageHasMediaInterface",
     *     mappedBy="media",
     *     cascade={"all"},
     *     orphanRemoval=true
     * )
     */
    protected $pageHasMedias;

    /**
     * @ORM\OneToMany(
     *      targetEntity="PiedWeb\CMSBundle\Entity\PageInterface",
     *      mappedBy="mainImage"
     * )
     */
    protected $mainImagePages;

    public function __toString()
    {
        return $this->name.' ';
    }

    protected function getExtension($string)
    {
        return preg_replace('/.*(\\.[^.\\s]{3,4})$/', '$1', $string);
    }

    protected function slugifyPreservingExtension($string)
    {
        $extension = $this->getExtension($string);
        $stringSlugify = (new Slugify())->slugify($this->removeExtension($string));

        return $stringSlugify.$extension;
    }

    public function getSlugForce()
    {
        return $this->slug;
    }

    /**
     * Used by MediaAdmin.
     */
    public function setSlugForce($slug)
    {
        if (!$slug) {
            return $this;
        }

        $this->slug = (new Slugify(['regexp' => '/([^A-Za-z0-9\.]|-)+/']))->slugify($slug);

        if ($this->media) {
            $this->setMedia($this->slug.$this->getExtension($this->media));
        }

        return $this;
    }

    /**
     * Used by VichUploader.
     */
    public function setSlug($slug)
    {
        if (!$slug) {
            return $this;
        }

        $slugSlugify = $this->slugifyPreservingExtension($slug);

        if ($this->getExtension($this->media) != $this->getExtension($slugSlugify)) { // 1;
            // TODO manage problem URL move... quick validation impossible before file upload, and impossible after from
            // here

            //$this->media ? $this->removeExtension($slugSlugify).$this->getExtension($this->media) :
            $this->setMedia($slugSlugify);
        }

        return $this;
    }

    /**
     * @Assert\Callback
     */
    public function validate(ExecutionContextInterface $context, $payload)

The parameter $payload is not used and could be removed.

    {
        if ($this->getMimeType() && $this->mediaFile && $this->mediaFile->getMimeType() != $this->getMimeType()) {
            $context
                ->buildViolation('Attention ! Vous essayez de remplacer un fichier d\'un type ('
                    .$this->getMimeType().') par un fichier d\'une autre type ('.$this->mediaFile->getMimeType().')')
                ->atPath('fileName')
                ->addViolation()
            ;
        }
    }

    protected function removeExtension($string)
    {
        return preg_replace('/\\.[^.\\s]{3,4}$/', '', $string);
    }

    public function getSlug(): string
    {
        if ($this->slug) {
            return $this->slug;
        }

        if ($this->media) {
            return $this->slug = $this->removeExtension($this->media);
        }

        $this->slug = (new Slugify())->slugify($this->getName()); //Urlizer::urlize($this->getName());

        return $this->slug;
    }

    public function setMediaFile(?File $media = null): void
    {
        $this->mediaFile = $media;

        if (null !== $media) {
            $this->updatedAt = new \DateTimeImmutable();
        }
    }

    public function getMediaFile(): ?File
    {
        return $this->mediaFile;
    }

    public function getMedia(): ?string
    {
        return $this->media;
    }

    public function setMedia($media): self
    {
        if (!$media) {
            return $this;
        }

        if (null !== $this->media) {
            $this->setMediaBeforeUpdate($this->media);
            //$this->media = $this->removeExtension($media).$this->getExtension($this->media);
        } //else

        $this->media = $media;

        return $this;
    }

    public function getName($getLocalized = null, $onlyLocalized = false): ?string
    {
        $names = $this->getNames(true);

        return $getLocalized ?
            (isset($names[$getLocalized]) ? $names[$getLocalized] : ($onlyLocalized ? null : $this->name))
            : $this->name;
    }

    public function getNames($yaml = false)
    {
        return true === $yaml && null !== $this->names ? Yaml::parse($this->names) : $this->names;
    }

    public function setNames(?string $names): self
    {
        $this->name = $names;

        return $this;
    }

    public function getNameByLocale($locale)
    {
        $names = $this->getNames(true);

        return $names[$locale] ?? $this->getName();
    }

    public function setName(?string $name): self
    {
        $this->name = $name;

        return $this;
    }

    public function getRelativeDir(): ?string
    {
        return rtrim($this->relativeDir, '/');
    }

    public function setRelativeDir($relativeDir): self
    {
        $this->relativeDir = rtrim($relativeDir, '/');

        return $this;
    }

    public function getMimeType(): ?string
    {
        return $this->mimeType;
    }

    protected function getPreviousMimeType()
    {
        return $this->previousMimeType ?? null;
    }

    public function setMimeType($mimeType): self
    {
        $this->mimeType = $mimeType;

        return $this;
    }

    public function getSize()
    {
        return $this->size;
    }

    public function setSize($size): self
    {
        $this->size = $size;

        return $this;
    }

    public function setDimensions($dimensions): self
    {
        if (isset($dimensions[0])) {
            $this->width = (int) $dimensions[0];
        }

        if (isset($dimensions[1])) {
            $this->height = (int) $dimensions[1];
        }

        return $this;
    }

    public function getDimensions(): array
    {
        return [$this->width, $this->height];
    }

    public function getRatio(): float
    {
        return $this->height / $this->width;
    }

    public function getWidth()
    {
        return $this->width;
    }

    public function getHeight()
    {
        return $this->height;
    }

    public function getMainColor(): ?string
    {
        return $this->mainColor;
    }

    public function getMainColorOpposite()
    {
        if (null === $this->getMainColor()) {
            return;
        }

        return Color::fromHex($this->getMainColor())->invert(true);
    }

    public function setMainColor(?string $mainColor): self
    {
        $this->mainColor = $mainColor;

        return $this;
    }

    public function setPageHasMedias($pageHasMedias)
    {
        $this->pageHasMedias = new ArrayCollection();
        foreach ($pageHasMedias as $pageHasMedia) {
            $this->addPageHasMedia($pageHasMedia);
        }
    }

    public function getPageHasMedias()
    {
        return $this->pageHasMedias;
    }

    public function addPageHasMedia(PageHasMedia $pageHasMedia)
    {
        $pageHasMedia->setMedia($this);
        $this->pageHasMedias[] = $pageHasMedia;
    }

    public function removePageHasMedia(PageHasMedia $pageHasMedia)
    {
        $this->pageHasMedias->removeElement($pageHasMedia);
    }

    public function getMainImagePages()
    {
        return $this->mainImagePages;
    }

    /**
     * @ORM\PreRemove
     */
    public function removeMainImageFromPages()
    {
        foreach ($this->mainImagePages as $page) {
            $page->setMainImage(null);
        }
    }

    public function getPath(): ?string
    {
        return $this->getFullPath();
    }

    public function getFullPath(): ?string
    {
        return null !== $this->media
            ? '/'.$this->getRelativeDir().($this->getMedia() ? '/'.$this->getMedia() : '')
            : null;
    }

    public function getFullPathWebP(): ?string
    {
        return null !== $this->media
            ? '/'.$this->getRelativeDir().($this->getSlug() ? '/'.$this->getSlug().'.webp' : '')
            : null;
    }

    /**
     * Get nOTE : this is used only for media renaming.
     *
     * @return string
     */
    public function getMediaBeforeUpdate()
    {
        return $this->mediaBeforeUpdate;
    }

    /**
     * Set nOTE : this is used only for media renaming.
     *
     * @param string $mediaBeforeUpdate NOTE : this is used only for media renaming
     *
     * @return self
     */
    public function setMediaBeforeUpdate(string $mediaBeforeUpdate)
    {
        $this->mediaBeforeUpdate = $mediaBeforeUpdate;

        return $this;
    }
}