StreamedResponseTrait.php

<?php
declare(strict_types=1);

/**
 * This source file is available under the terms of the
 * Pimcore Open Core License (POCL)
 * Full copyright and license information is available in
 * LICENSE.md which is distributed with this source code.
 *
 *  @copyright  Copyright (c) Pimcore GmbH (https://www.pimcore.com)
 *  @license    Pimcore Open Core License (POCL)
 */

namespace Pimcore\Bundle\StudioBackendBundle\Util\Trait;

use League\Flysystem\FilesystemException;
use League\Flysystem\FilesystemOperator;
use Pimcore\Bundle\StudioBackendBundle\Exception\Api\ElementStreamResourceNotFoundException;
use Pimcore\Bundle\StudioBackendBundle\Exception\Api\StreamResourceNotFoundException;
use Pimcore\Bundle\StudioBackendBundle\Util\Constant\HttpResponseCodes;
use Pimcore\Bundle\StudioBackendBundle\Util\Constant\HttpResponseHeaders;
use Pimcore\Model\Asset;
use Pimcore\Model\Asset\Thumbnail\ImageThumbnailInterface;
use Pimcore\Model\Asset\Video;
use Pimcore\Model\Asset\Video\ImageThumbnailInterface as VideoImageThumbnailInterface;
use Closure;
use Symfony\Component\HttpFoundation\StreamedResponse;
use function is_resource;
use function sprintf;

/**
 * @internal
 */
trait StreamedResponseTrait
{
    /**
     * @throws ElementStreamResourceNotFoundException
     */
    protected function getStreamedResponse(
        Asset|VideoImageThumbnailInterface|ImageThumbnailInterface $element,
        string $contentDisposition = HttpResponseHeaders::ATTACHMENT_TYPE->value,
        array $additionalHeaders = [],
        ?int $fileSize = null,
    ): StreamedResponse {
        $stream = $element->getStream();
        $asset = $this->getAsset($element);

        if (!is_resource($stream)) {
            throw new ElementStreamResourceNotFoundException(
                $asset->getId(),
                $asset->getType()
            );
        }

        if (!$fileSize) {
            $fileSize = $element->getFileSize();
        }

        return new StreamedResponse(
            function () use ($stream) {
                fpassthru($stream);
            },
            HttpResponseCodes::SUCCESS->value,
            $this->getResponseHeaders(
                mimeType: $element->getMimeType(),
                fileSize: $fileSize,
                filename: $asset->getFilename(),
                contentDisposition: $contentDisposition,
                additionalHeaders: $additionalHeaders
            )
        );
    }

    /**
     * @throws FilesystemException
     */
    protected function getVideoStreamedResponse(
        Video $video,
        FilesystemOperator $storage,
        string $storagePath,
        string $contentDisposition = HttpResponseHeaders::ATTACHMENT_TYPE->value,
    ): StreamedResponse {
        $stream = $storage->readStream($storagePath);

        return new StreamedResponse(
            function () use ($stream) {
                fpassthru($stream);
            },
            HttpResponseCodes::SUCCESS->value,
            $this->getResponseHeaders(
                mimeType: 'video/mp4',
                fileSize: $storage->fileSize($storagePath),
                filename: $video->getFilename(),
                contentDisposition: $contentDisposition,
                additionalHeaders: [
                    HttpResponseHeaders::HEADER_ACCEPT_RANGES->value => 'bytes',
                ]
            )
        );
    }

    /**
     * @throws StreamResourceNotFoundException
     */
    protected function getFileStreamedResponse(
        string $path,
        string $mimeType,
        string $filename,
        FilesystemOperator $storage,
        string $contentDisposition = HttpResponseHeaders::ATTACHMENT_TYPE->value,
        ?Closure $onStreamComplete = null,
    ): StreamedResponse {
        try {
            $stream = $storage->readStream($path);

            return new StreamedResponse(
                function () use ($stream, $onStreamComplete) {
                    fpassthru($stream);
                    if ($onStreamComplete !== null) {
                        $onStreamComplete();
                    }
                },
                HttpResponseCodes::SUCCESS->value,
                $this->getResponseHeaders(
                    mimeType: $mimeType,
                    fileSize: $storage->fileSize($path),
                    filename: $filename,
                    contentDisposition: $contentDisposition
                ),
            );

        } catch (FilesystemException $e) {
            throw new StreamResourceNotFoundException(
                sprintf(
                    'Could not process stream for file %s: %s',
                    $path,
                    $e->getMessage()
                )
            );
        }

    }

    private function getAsset(Asset|VideoImageThumbnailInterface|ImageThumbnailInterface $element): Asset
    {
        if ($element instanceof Asset) {
            return $element;
        }

        return $element->getAsset();
    }

    private function getResponseHeaders(
        string $mimeType,
        int $fileSize,
        string $filename,
        string $contentDisposition,
        array $additionalHeaders = []
    ): array {
        return array_merge($additionalHeaders, [
            HttpResponseHeaders::HEADER_CONTENT_TYPE->value => $mimeType,
            HttpResponseHeaders::HEADER_CONTENT_DISPOSITION->value => sprintf(
                '%s; filename="%s"',
                $contentDisposition,
                $filename
            ),
            HttpResponseHeaders::HEADER_CONTENT_LENGTH->value => $fileSize,
        ]);
    }
}