Wopi::makeDocumentNotFoundResponse() - Code Metrics - Inspection of "chore(deps): bump php-actions/phpunit from 3 to 9" - Champs-Libres/wopi-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#34)

unknown
created 2023-01-09 13:08 UTC
Wopi::makeDocumentNotFoundResponse() A

↳ Parent: Wopi
Complexity

Conditions	1
Paths	1
Size

Total Lines	5
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes	1
Bugs	1	Features	0
Metric	Value
cc	1
eloc	3
c	1
b	1
f	0
nc	1
nop	1
dl	0
loc	5
rs	10
ccs	0
cts	3
cp	0
crap	2
<?php

/**
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

declare(strict_types=1);

namespace ChampsLibres\WopiBundle\Service;

use ChampsLibres\WopiBundle\Service\Wopi\PutFile;
use ChampsLibres\WopiLib\Contract\Service\DocumentManagerInterface;
use ChampsLibres\WopiLib\Contract\Service\WopiInterface;
use DateTimeInterface;
use Psr\Cache\CacheItemPoolInterface;
use Psr\Http\Message\RequestInterface;

use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface;

use Psr\Http\Message\StreamFactoryInterface;
use Psr\Http\Message\UriFactoryInterface;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;

use const PATHINFO_EXTENSION;
use const PATHINFO_FILENAME;

final class Wopi implements WopiInterface
{
    private CacheItemPoolInterface $cache;

    private DocumentManagerInterface $documentManager;

    private PutFile $putFileExecutor;

    private ResponseFactoryInterface $responseFactory;

    private RouterInterface $router;

    private StreamFactoryInterface $streamFactory;

    private TokenStorageInterface $tokenStorage;

    private UriFactoryInterface $uriFactory;

    public function __construct(
        CacheItemPoolInterface $cache,
        DocumentManagerInterface $documentManager,
        ResponseFactoryInterface $responseFactory,
        RouterInterface $router,
        StreamFactoryInterface $streamFactory,
        TokenStorageInterface $tokenStorage,
        UriFactoryInterface $uriFactory,
        PutFile $putFile
    ) {
        $this->cache = $cache;
        $this->documentManager = $documentManager;
        $this->responseFactory = $responseFactory;
        $this->streamFactory = $streamFactory;
        $this->router = $router;
        $this->tokenStorage = $tokenStorage;
        $this->uriFactory = $uriFactory;
        $this->putFileExecutor = $putFile;
    }

    public function checkFileInfo(string $fileId, string $accessToken, RequestInterface $request): ResponseInterface
    {
        $document = $this->documentManager->findByDocumentId($fileId);

        if (null === $document) {
            return $this->makeDocumentNotFoundResponse($fileId);
        }

        $userIdentifier = $this->tokenStorage->getToken()->getUser()->getUserIdentifier();
        $userCacheKey = sprintf('wopi_putUserInfo_%s', $this->tokenStorage->getToken()->getUser()->getUserIdentifier());

        return $this
            ->responseFactory
            ->createResponse()
            ->withHeader('Content-Type', 'application/json')
            ->withBody($this->streamFactory->createStream((string) json_encode(
                [
                    'BaseFileName' => $this->documentManager->getBasename($document),
                    'OwnerId' => 'Symfony',
                    'Size' => $this->documentManager->getSize($document),
                    'UserId' => $userIdentifier,
                    'ReadOnly' => false,
                    'UserCanAttend' => true,
                    'UserCanPresent' => true,
                    'UserCanRename' => true,
                    'UserCanWrite' => true,
                    'UserCanNotWriteRelative' => false,
                    'SupportsUserInfo' => true,
                    'SupportsDeleteFile' => true,
                    'SupportsLocks' => true,
                    'SupportsGetLock' => true,
                    'SupportsExtendedLockLength' => true,
                    'UserFriendlyName' => $userIdentifier,
                    'SupportsUpdate' => true,
                    'SupportsRename' => true,
                    'DisablePrint' => false,
                    'AllowExternalMarketplace' => true,
                    'SupportedShareUrlTypes' => [
                        'ReadOnly',
                    ],
                    'SHA256' => $this->documentManager->getSha256($document),
                    'UserInfo' => (string) $this->cache->getItem($userCacheKey)->get(),
                    'LastModifiedTime' => $this->documentManager->getLastModifiedDate($document)
                        ->format(DateTimeInterface::ATOM),
                ]
            )));
    }

    public function deleteFile(string $fileId, string $accessToken, RequestInterface $request): ResponseInterface
    {
        $document = $this->documentManager->findByDocumentId($fileId);

        if (null === $document) {
            return $this->makeDocumentNotFoundResponse($fileId);
        }

        $this->documentManager->remove($document);

        return $this
            ->responseFactory
            ->createResponse(200);
    }

    public function enumerateAncestors(
        string $fileId,
        string $accessToken,
        RequestInterface $request
    ): ResponseInterface {
        return $this
            ->responseFactory
            ->createResponse(501);
    }

    public function getFile(
        string $fileId,
        string $accessToken,
        RequestInterface $request
    ): ResponseInterface {
        $document = $this->documentManager->findByDocumentId($fileId);

        if (null === $document) {
            return $this->makeDocumentNotFoundResponse($fileId);
        }

        $revision = $this->documentManager->getVersion($document);
        $content = $this->documentManager->read($document);

        return $this
            ->responseFactory
            ->createResponse()
            ->withHeader(
                WopiInterface::HEADER_ITEM_VERSION,
                sprintf('v%s', $revision)
            )
            ->withHeader(
                'Content-Type',
                'application/octet-stream',
            )
            ->withHeader(
                'Content-Length',
                (string) $this->documentManager->getSize($document)
            )
            ->withHeader(
                'Content-Disposition',
                sprintf('attachment; filename=%s', $this->documentManager->getBasename($document))
            )
            ->withBody($content);
    }

    public function getLock(string $fileId, string $accessToken, RequestInterface $request): ResponseInterface
    {
        $document = $this->documentManager->findByDocumentId($fileId);

        if (null === $document) {
            return $this->makeDocumentNotFoundResponse($fileId);
        }

        if ($this->documentManager->hasLock($document)) {
            return $this
                ->responseFactory
                ->createResponse()
                ->withHeader(WopiInterface::HEADER_LOCK, $this->documentManager->getLock($document));
        }

        return $this
            ->responseFactory
            ->createResponse(404)
            ->withHeader(WopiInterface::HEADER_LOCK, '');
    }

    public function getShareUrl(string $fileId, string $accessToken, RequestInterface $request): ResponseInterface
    {
        return $this
            ->responseFactory
            ->createResponse(501);
    }

    public function lock(
        string $fileId,
        string $accessToken,
        string $xWopiLock,
        RequestInterface $request
    ): ResponseInterface {
        $document = $this->documentManager->findByDocumentId($fileId);

        if (null === $document) {
            return $this->makeDocumentNotFoundResponse($fileId);
        }

        $version = $this->documentManager->getVersion($document);

        if ($this->documentManager->hasLock($document)) {
            if ($xWopiLock === $currentLock = $this->documentManager->getLock($document)) {
                return $this->refreshLock($fileId, $accessToken, $xWopiLock, $request);
            }

            return $this
                ->responseFactory
                ->createResponse(409)
                ->withHeader(WopiInterface::HEADER_LOCK, $currentLock)
                ->withHeader(
                    WopiInterface::HEADER_ITEM_VERSION,
                    sprintf('v%s', $version)
                );
        }

        $this->documentManager->lock($document, $xWopiLock);

        return $this
            ->responseFactory
            ->createResponse()
            ->withHeader(
                WopiInterface::HEADER_ITEM_VERSION,
                sprintf('v%s', $version)
            );
    }

    public function putFile(
        string $fileId,
        string $accessToken,
        string $xWopiLock,
        string $xWopiEditors,
        RequestInterface $request
    ): ResponseInterface {
        return ($this->putFileExecutor)($fileId, $accessToken, $xWopiLock, $xWopiEditors, $request);
    }

    public function putRelativeFile(
        string $fileId,
        string $accessToken,
        ?string $suggestedTarget,
        ?string $relativeTarget,
        bool $overwriteRelativeTarget,
        int $size,
        RequestInterface $request
    ): ResponseInterface {
        if ((null === $suggestedTarget) && (null === $relativeTarget)) {
            return $this
                ->responseFactory
                ->createResponse(400)
                ->withBody($this->streamFactory->createStream((string) json_encode([
                    'message' => 'target is null',
                ])));
        }

        if (null !== $suggestedTarget) {
            // If it starts with a dot...
            if (0 === strpos($suggestedTarget, '.', 0)) {
                $document = $this->documentManager->findByDocumentId($fileId);

                if (null === $document) {
                    return $this->makeDocumentNotFoundResponse();
                    return $this->/** @scrutinizer ignore-call */ makeDocumentNotFoundResponse();
                }
                $filename = pathinfo($this->documentManager->getBasename($document), PATHINFO_EXTENSION | PATHINFO_FILENAME);

                $suggestedTarget = sprintf('%s%s', $filename, $suggestedTarget);
                $suggestedTarget = sprintf('%s%s', /** @scrutinizer ignore-type */ $filename, $suggestedTarget);
            }

            $target = $suggestedTarget;
        }

        if (null !== $relativeTarget) {
            $document = $this->documentManager->findByDocumentFilename($relativeTarget);

            /**
             * If a file with the specified name already exists,
             * the host must respond with a 409 Conflict,
             * unless the X-WOPI-OverwriteRelativeTarget request header is set to true.
             *
             * When responding with a 409 Conflict for this reason,
             * the host may include an X-WOPI-ValidRelativeTarget specifying a file name that is valid.
             *
             * If the X-WOPI-OverwriteRelativeTarget request header is set to true
             * and a file with the specified name already exists and is locked,
             * the host must respond with a 409 Conflict and include an
             * X-WOPI-Lock response header containing the value of the current lock on the file.
             */
            if (null !== $document) {
                if (false === $overwriteRelativeTarget) {
                    $extension = pathinfo($this->documentManager->getBasename($document), PATHINFO_EXTENSION);

                    return $this
                        ->responseFactory
                        ->createResponse(409)
                        ->withHeader('Content-Type', 'application/json')
                        ->withHeader(
                            WopiInterface::HEADER_VALID_RELATIVE_TARGET,
                            sprintf('%s.%s', uniqid(), $extension)
                        );
                }

                if ($this->documentManager->hasLock($document)) {
                    return $this
                        ->responseFactory
                        ->createResponse(409)
                        ->withHeader(WopiInterface::HEADER_LOCK, $this->documentManager->getLock($document));
                }
            }

            $target = $relativeTarget;
        }

        $pathInfo = pathinfo($target, PATHINFO_EXTENSION | PATHINFO_FILENAME);


        $new = $this->documentManager->create([
            'basename' => $target,
            'name' => $pathInfo['filename'],
            'extension' => $pathInfo['extension'],
            'content' => (string) $request->getBody(),
            'size' => $request->getHeaderLine(WopiInterface::HEADER_SIZE),
        ]);

        $this->documentManager->write($new);

        $uri = $this
            ->uriFactory
            ->createUri(
                $this
                    ->router
                    ->generate(
                        'checkFileInfo',
                        [
                            'fileId' => $this->documentManager->getDocumentId($new),
                        ],
                        RouterInterface::ABSOLUTE_URL
                    )
            )
            ->withQuery(http_build_query([
                'access_token' => $accessToken,
            ]));

        $properties = [
            'Name' => $this->documentManager->getBasename($new),
            'Url' => (string) $uri,
            'HostEditUrl' => $this->documentManager->getDocumentId($new),
            'HostViewUrl' => $this->documentManager->getDocumentId($new),
        ];

        return $this
            ->responseFactory
            ->createResponse()
            ->withHeader('Content-Type', 'application/json')
            ->withBody($this->streamFactory->createStream((string) json_encode($properties)));
    }

    public function putUserInfo(string $fileId, string $accessToken, RequestInterface $request): ResponseInterface
    {
        $userCacheKey = sprintf('wopi_putUserInfo_%s', $this->tokenStorage->getToken()->getUser()->getUserIdentifier());

        $cacheItem = $this->cache->getItem($userCacheKey);
        $cacheItem->set((string) $request->getBody());
        $this->cache->save($cacheItem);

        return $this
            ->responseFactory
            ->createResponse();
    }

    public function refreshLock(
        string $fileId,
        string $accessToken,
        string $xWopiLock,
        RequestInterface $request
    ): ResponseInterface {
        $this->unlock($fileId, $accessToken, $xWopiLock, $request);

        return $this->lock($fileId, $accessToken, $xWopiLock, $request);
    }

    public function renameFile(
        string $fileId,
        string $accessToken,
        string $xWopiLock,
        string $xWopiRequestedName,
        RequestInterface $request
    ): ResponseInterface {
        $document = $this->documentManager->findByDocumentId($fileId);

        if (null === $document) {
            return $this->makeDocumentNotFoundResponse($fileId);
        }

        if ($this->documentManager->hasLock($document)) {
            if ($xWopiLock !== $currentLock = $this->documentManager->getLock($document)) {
                return $this
                    ->responseFactory
                    ->createResponse(409)
                    ->withHeader(WopiInterface::HEADER_LOCK, $currentLock);
            }
        }

        $this->documentManager->write($document, ['filename' => $xWopiRequestedName]);

        $data = [
            'Name' => $xWopiRequestedName,
        ];

        return $this
            ->responseFactory
            ->createResponse(200)
            ->withHeader('Content-Type', 'application/json')
            ->withBody(
                $this->streamFactory->createStream((string) json_encode($data))
            );
    }

    public function unlock(
        string $fileId,
        string $accessToken,
        string $xWopiLock,
        RequestInterface $request
    ): ResponseInterface {
        $document = $this->documentManager->findByDocumentId($fileId);

        if (null === $document) {
            return $this->makeDocumentNotFoundResponse($fileId);
        }

        $version = $this->documentManager->getVersion($document);

        if (!$this->documentManager->hasLock($document)) {
            return $this
                ->responseFactory
                ->createResponse(409)
                ->withHeader(WopiInterface::HEADER_LOCK, '');
        }

        $currentLock = $this->documentManager->getLock($document);

        if ($currentLock !== $xWopiLock) {
            return $this
                ->responseFactory
                ->createResponse(409)
                ->withHeader(WopiInterface::HEADER_LOCK, $currentLock);
        }

        $this->documentManager->deleteLock($document);

        return $this
            ->responseFactory
            ->createResponse()
            ->withHeader(WopiInterface::HEADER_LOCK, '')
            ->withHeader(
                WopiInterface::HEADER_ITEM_VERSION,
                sprintf('v%s', $version)
            );
    }

    public function unlockAndRelock(
        string $fileId,
        string $accessToken,
        string $xWopiLock,
        string $xWopiOldLock,
        RequestInterface $request
    ): ResponseInterface {
        $this->unlock($fileId, $accessToken, $xWopiOldLock, $request);

        return $this->lock($fileId, $accessToken, $xWopiLock, $request);
    }

    private function makeDocumentNotFoundResponse(string $fileId): ResponseInterface
    {
        return $this->responseFactory->createResponse(404)
            ->withBody($this->streamFactory->createStream((string) json_encode([
                'message' => "Document with id {$fileId} not found",
            ])));
    }
}

Champs-Libres / wopi-bundle

Pull Request — master (#34)

Wopi::makeDocumentNotFoundResponse() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
