Spatie\MediaLibrary\FileManipulator

Complexity

Total Complexity

12

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	createDerivedFiles()	0	15	2
B	performConversions()	0	39	4
A	performConversion()	0	16	1
A	dispatchQueuedConversions()	0	10	2
A	getTemporaryDirectoryPath()	0	10	2
A	determineImageGenerator()	0	10	1

<?php

namespace Spatie\MediaLibrary;

use Spatie\Image\Image;
use Illuminate\Support\Facades\File;
use Illuminate\Contracts\Bus\Dispatcher;
use Spatie\MediaLibrary\Conversion\Conversion;
use Spatie\MediaLibrary\Filesystem\Filesystem;
use Spatie\MediaLibrary\Jobs\PerformConversions;
use Spatie\TemporaryDirectory\TemporaryDirectory;
use Spatie\MediaLibrary\ImageGenerators\ImageGenerator;
use Spatie\MediaLibrary\Conversion\ConversionCollection;
use Spatie\MediaLibrary\Events\ConversionHasBeenCompleted;
use Spatie\MediaLibrary\Helpers\File as MediaLibraryFileHelper;

class FileManipulator
{
    /**
     * Create all derived files for the given media.
     *
     * @param \Spatie\MediaLibrary\Media $media
     */
    public function createDerivedFiles(Media $media)
    {
        $profileCollection = ConversionCollection::createForMedia($media);

        $this->performConversions(
            $profileCollection->getNonQueuedConversions($media->collection_name),
            $media
        );

        $queuedConversions = $profileCollection->getQueuedConversions($media->collection_name);

        if ($queuedConversions->isNotEmpty()) {
            $this->dispatchQueuedConversions($media, $queuedConversions);
        }
    }

    /**
     * Perform the given conversions for the given media.
     *
     * @param \Spatie\MediaLibrary\Conversion\ConversionCollection $conversions
     * @param \Spatie\MediaLibrary\Media $media
     */
    public function performConversions(ConversionCollection $conversions, Media $media)
    {
        if ($conversions->isEmpty()) {
            return;
        }

        $imageGenerator = $this->determineImageGenerator($media);

        if (! $imageGenerator) {
            return;
        }

        $temporaryDirectory = new TemporaryDirectory($this->getTemporaryDirectoryPath());

        $copiedOriginalFile = app(Filesystem::class)->copyFromMediaLibrary(
            $media,
            $temporaryDirectory->path(str_random(16).'.'.$media->extension)
        );

        foreach ($conversions as $conversion) {
            $copiedOriginalFile = $imageGenerator->convert($copiedOriginalFile, $conversion);

            $conversionResult = $this->performConversion($media, $conversion, $copiedOriginalFile);

            $newFileName = $conversion->getName()
                .'.'
                .$conversion->getResultExtension(pathinfo($copiedOriginalFile, PATHINFO_EXTENSION));

            $renamedFile = MediaLibraryFileHelper::renameInDirectory($conversionResult, $newFileName);

            app(Filesystem::class)->copyToMediaLibrary($renamedFile, $media, true);

            event(new ConversionHasBeenCompleted($media, $conversion));

            unlink($renamedFile);
        }

        unlink($copiedOriginalFile);
    }

    public function performConversion(Media $media, Conversion $conversion, string $imageFile): string
    {
        $conversionTempFile = pathinfo($imageFile, PATHINFO_DIRNAME).'/'.str_random(16)
            .$conversion->getName()
            .'.'
            .$media->extension;

        File::copy($imageFile, $conversionTempFile);

        Image::load($conversionTempFile)
            ->useImageDriver(config('medialibrary.image_driver'))
            ->manipulate($conversion->getManipulations())
            ->save();

        return $conversionTempFile;
    }

    protected function dispatchQueuedConversions(Media $media, ConversionCollection $queuedConversions)
    {
        $job = new PerformConversions($queuedConversions, $media);

        if ($customQueue = config('medialibrary.queue_name')) {
            $job->onQueue($customQueue);
        }

        app(Dispatcher::class)->dispatch($job);
    }

    /**
     * @return string
     */
    protected function getTemporaryDirectoryPath(): string
    {
        $path = config('medialibrary.temp_file_path');

        if ($path !== null) {
            return $path;
        }

        return storage_path('medialibrary/temp');
    }

    /**
     * @param \Spatie\MediaLibrary\Media $media
     *
     * @return \Spatie\MediaLibrary\ImageGenerators\ImageGenerator|null
     */
    public function determineImageGenerator(Media $media)
    {
        return $media->getImageGenerators()
            ->map(function (string $imageGeneratorClassName) {
                return app($imageGeneratorClassName);
            })
            ->first(function (ImageGenerator $imageGenerator) use ($media) {
                return $imageGenerator->canConvert($media);
            });
    }
}