Spatie\MediaLibrary\Conversion\ConversionCollection

Complexity

Total Complexity

16

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	5

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	createForMedia()	0	4	1
A	setMedia()	0	10	1
A	getByName()	0	12	2
A	addConversionsFromRelatedModel()	0	16	2
A	addManipulationsFromDb()	0	6	2
A	getConversions()	0	10	2
A	getQueuedConversions()	0	6	1
A	addManipulationToConversion()	0	10	3
A	getNonQueuedConversions()	0	6	1
A	getConversionsFiles()	0	6	1

<?php

namespace Spatie\MediaLibrary\Conversion;

use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use Illuminate\Database\Eloquent\Relations\Relation;
use Spatie\MediaLibrary\Exceptions\InvalidConversion;
use Spatie\MediaLibrary\HasMedia\Interfaces\HasMediaConversions;
use Spatie\MediaLibrary\Media;

class ConversionCollection extends Collection
{
    /**
     * @param \Spatie\MediaLibrary\Media $media
     *
     * @return static
     */
    public static function createForMedia(Media $media)
    {
        return (new static())->setMedia($media);
    }

    /**
     * @param \Spatie\MediaLibrary\Media $media
     *
     * @return $this
     */
    public function setMedia(Media $media)
    {
        $this->items = [];

        $this->addConversionsFromRelatedModel($media);

        $this->addManipulationsFromDb($media);

        return $this;
    }

    /**
     *  Get a conversion by it's name.
     *
     * @param string $name
     *
     * @return mixed
     *
     * @throws \Spatie\MediaLibrary\Exceptions\InvalidConversion
     */
    public function getByName(string $name)
    {
        $conversion = $this->first(function ($key, Conversion $conversion) use ($name) {
            return $conversion->getName() === $name;
        });

        if (!$conversion) {
            throw InvalidConversion::unknownName($name);
        }

        return $conversion;
    }

    /**
     * Add the conversion that are defined on the related model of
     * the given media.
     *
     * @param \Spatie\MediaLibrary\Media $media
     */
    protected function addConversionsFromRelatedModel(Media $media)
    {
        $modelName = Arr::get(Relation::morphMap(), $media->model_type, $media->model_type);

        /*
         * To prevent an sql query create a new model instead
         * of the using the associated one
         */
        $model = new $modelName();

        if ($model instanceof HasMediaConversions) {
            $model->registerMediaConversions();
        }

        $this->items = $model->mediaConversions;
    }

    /**
     * Add the extra manipulations that are defined on the given media.
     *
     * @param \Spatie\MediaLibrary\Media $media
     */
    protected function addManipulationsFromDb(Media $media)
    {
        foreach ($media->manipulations as $conversionName => $manipulation) {
            $this->addManipulationToConversion($manipulation, $conversionName);
        }
    }

    /**
     * Get all the conversions in the collection.
     *
     * @param string $collectionName
     *
     * @return $this
     */
    public function getConversions(string $collectionName = '')
    {
        if ($collectionName === '') {
            return $this;
        }

        return $this->filter(function (Conversion $conversion) use ($collectionName) {
            return $conversion->shouldBePerformedOn($collectionName);
        });
    }

    /*
     * Get all the conversions in the collection that should be queued.
     */
    public function getQueuedConversions(string $collectionName = '') : ConversionCollection
    {
        return $this->getConversions($collectionName)->filter(function (Conversion $conversion) {
            return $conversion->shouldBeQueued();
        });
    }

    /*
     * Add the given manipulation to the conversion with the given name.
     */
    protected function addManipulationToConversion(array $manipulation, string $conversionName)
    {
        foreach ($this as $conversion) {
            if ($conversion->getName() === $conversionName) {
                $conversion->addAsFirstManipulation($manipulation);

                return;
            }
        }
    }

    /*
     * Get all the conversions in the collection that should not be queued.
     */
    public function getNonQueuedConversions(string $collectionName = '') : ConversionCollection
    {
        return $this->getConversions($collectionName)->filter(function (Conversion $conversion) {
            return !$conversion->shouldBeQueued();
        });
    }

    /**
     * Return the list of conversion files.
     */
    public function getConversionsFiles(string $collectionName = '') : ConversionCollection
    {
        return $this->getConversions($collectionName)->map(function (Conversion $conversion) {
            return $conversion->getName() . '.' . $conversion->getResultExtension();
        });
    }
}