Phauthentic\Infrastructure\Storage\Processor\Image\ImageProcessor

Complexity

Total Complexity

20

Size/Duplication

Total Lines	241
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
B	process()	0	55	8
A	setMimeTypes()	0	5	1
A	__construct()	0	8	1
A	processOnlyTheseVariants()	0	5	1
A	processAll()	0	5	1
A	optimizeAndStore()	0	33	1
A	copyOriginalFileData()	0	18	2
A	isApplicable()	0	4	2
A	shouldProcessVariant()	0	9	3

<?php

/**
 * Copyright (c) Florian Krämer (https://florian-kraemer.net)
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright Copyright (c) Florian Krämer (https://florian-kraemer.net)
 * @author    Florian Krämer
 * @link      https://github.com/Phauthentic
 * @license   https://opensource.org/licenses/MIT MIT License
 */

declare(strict_types=1);

namespace Phauthentic\Infrastructure\Storage\Processor\Image;

use GuzzleHttp\Psr7\StreamWrapper;
use Intervention\Image\Image;
use Intervention\Image\ImageManager;
use League\Flysystem\Config;
use Phauthentic\Infrastructure\Storage\FileInterface;
use Phauthentic\Infrastructure\Storage\Processor\Image\Exception\TempFileCreationFailedException;
use Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface;
use Phauthentic\Infrastructure\Storage\FileStorageInterface;
use Phauthentic\Infrastructure\Storage\Processor\ProcessorInterface;
use Phauthentic\Infrastructure\Storage\Utility\TemporaryFile;

use function Phauthentic\Infrastructure\Storage\fopen;

/**
 * Image Operator
 */
class ImageProcessor implements ProcessorInterface
{
    use OptimizerTrait;

    /**
     * @var array
     */
    protected array $mimeTypes = [
        'image/gif',
        'image/jpg',
        'image/jpeg',
        'image/png'
    ];

    /**
     * @var array
     */
    protected array $processOnlyTheseVariants = [];

    /**
     * @var \Phauthentic\Infrastructure\Storage\FileStorageInterface
     */
    protected FileStorageInterface $storageHandler;

    /**
     * @var \Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface
     */
    protected PathBuilderInterface $pathBuilder;

    /**
     * @var \Intervention\Image\ImageManager
     */
    protected ImageManager $imageManager;

    /**
     * @var \Intervention\Image\Image
     */
    protected Image $image;

    /**
     * @param \Phauthentic\Infrastructure\Storage\FileStorageInterface $storageHandler File Storage Handler
     * @param \Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface $pathBuilder Path Builder
     * @param \Intervention\Image\ImageManager $imageManager Image Manager
     */
    public function __construct(
        FileStorageInterface $storageHandler,
        PathBuilderInterface $pathBuilder,
        ImageManager $imageManager
    ) {
        $this->storageHandler = $storageHandler;
        $this->pathBuilder = $pathBuilder;
        $this->imageManager = $imageManager;
    }

    /**
     * @param array $mimeTypes Mime Type List
     * @return $this
     */
    protected function setMimeTypes(array $mimeTypes): self
    {
        $this->mimeTypes = $mimeTypes;

        return $this;
    }

    /**
     * @param \Phauthentic\Infrastructure\Storage\FileInterface $file File
     * @return bool
     */
    protected function isApplicable(FileInterface $file): bool
    {
        return $file->hasVariants()
            && in_array($file->mimeType(), $this->mimeTypes, true);
    }

    /**
     * @param array $variants Variants by name
     * @return $this
     */
    public function processOnlyTheseVariants(array $variants): self
    {
        $this->processOnlyTheseVariants = $variants;

        return $this;
    }

    /**
     * @return $this
     */
    public function processAll(): self
    {
        $this->processOnlyTheseVariants = [];

        return $this;
    }

    /**
     * Read the data from the files resource if (still) present,
     * if not fetch it from the storage backend and write the data
     * to the stream of the temp file
     *
     * @param \Phauthentic\Infrastructure\Storage\FileInterface $file File
     * @param resource $tempFileStream Temp File Stream Resource
     * @return int|bool False on error
     */
    protected function copyOriginalFileData(FileInterface $file, $tempFileStream)
    {
        $stream = $file->resource();
        $storage = $this->storageHandler->getStorage($file->storage());

        if ($stream === null) {
            $stream = $storage->readStream($file->path());
            $stream = $stream['stream'];
        } else {
            rewind($stream);
        }
        $result = stream_copy_to_stream(
            $stream,
            $tempFileStream
        );
        fclose($tempFileStream);

        return $result;
    }

    /**
     * @param string $variant Variant name
     * @param array $variantData Variant data
     * @return bool
     */
    protected function shouldProcessVariant(string $variant, array $variantData): bool
    {
        return !(
            // Empty operations
            empty($variantData['operations'])
            || (
                // Check if the operation should be processed
                !empty($this->processOnlyTheseVariants)
                && !in_array($variant, $this->processOnlyTheseVariants, true)
            )
        );
    }

    /**
     * @inheritDoc
     */
    public function process(FileInterface $file): FileInterface
    {
        if (!$this->isApplicable($file)) {
            return $file;
        }

        $storage = $this->storageHandler->getStorage($file->storage());

        // Create a local tmp file on the processing system / machine
        $tempFile = TemporaryFile::create();
        $tempFileStream = fopen($tempFile, 'wb+');

        // Read the data from the files resource if (still) present,
        // if not fetch it from the storage backend and write the data
        // to the stream of the temp file
        $result = $this->copyOriginalFileData($file, $tempFileStream);

        // Stop if the temp file could not be generated
        if ($result === false) {
            throw TempFileCreationFailedException::withFilename($tempFile);
        }

        // Iterate over the variants described as an array
        foreach ($file->variants() as $variant => $data) {
            if (!$this->shouldProcessVariant($variant, $data)) {
                continue;
            }

            $this->image = $this->imageManager->make($tempFile);
            $operations = new Operations($this->image);

            // Apply the operations
            foreach ($data['operations'] as $operation => $arguments) {
                $operations->{$operation}($arguments);
            }

            $path = $this->pathBuilder->pathForVariant($file, $variant);

            if (isset($data['optimize']) && $data['optimize'] === true) {
                $this->optimizeAndStore($file, $path);
            } else {
                $storage->writeStream(
                    $path,
                    StreamWrapper::getResource($this->image->stream($file->extension(), 90)),
                    new Config()
                );
            }

            $data['path'] = $path;
            $file = $file->withVariant($variant, $data);
        }

        unlink($tempFile);

        return $file;
    }

    /**
     * @param \Phauthentic\Infrastructure\Storage\FileInterface $file File
     * @param string $path Path
     * @return void
     */
    protected function optimizeAndStore(FileInterface $file, string $path): void
    {
        $storage = $this->storageHandler->getStorage($file->storage());

        // We need more tmp files because the optimizer likes to write
        // and read the files from disk, not from a stream. :(
        $optimizerTempFile = TemporaryFile::create();
        $optimizerOutput = TemporaryFile::create();

        // Save the image to the tmp file
        $this->image->save($optimizerTempFile, 90, $file->extension());
        // Optimize it and write it to another file
        $this->optimizer()->optimize($optimizerTempFile, $optimizerOutput);
        // Open a new stream for the storage system
        $optimizerOutputHandler = fopen($optimizerOutput, 'rb+');

        // And store it...
        $storage->writeStream(
            $path,
            $optimizerOutputHandler,
            new Config()
        );

        // Cleanup
        fclose($optimizerOutputHandler);
        unlink($optimizerTempFile);
        unlink($optimizerOutput);

        // Cleanup
        unset(
            $optimizerOutputHandler,
            $optimizerTempFile,
            $optimizerOutput
        );
    }
}