UploadableResourceMetadataCollectionFactory::generateUploadItemOperation() - Code Metrics - Inspection of "Fix interface conflict/updates" - components-web-app/api-components-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Pull Request — main (#139)

by Daniel
created 2022-04-24 19:27 UTC
generateUploadItemOperation() A

↳ Parent: UploadableResourceMetadataCollectionFactory
Complexity

Conditions	1
Paths	1
Size

Total Lines	11
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	8
nc	1
nop	3
dl	0
loc	11
rs	10
c	1
b	0
f	0
<?php

/*
 * This file is part of the Silverback API Components Bundle Project
 *
 * (c) Daniel West <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Silverback\ApiComponentsBundle\ApiPlatform\Metadata\Resource;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\Metadata\Post;
use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
use ApiPlatform\Metadata\Resource\ResourceMetadataCollection;
use ApiPlatform\Operation\PathSegmentNameGeneratorInterface;
use JetBrains\PhpStorm\Pure;
use Silverback\ApiComponentsBundle\Action\Uploadable\DownloadAction;
use Silverback\ApiComponentsBundle\Action\Uploadable\UploadAction;
use Silverback\ApiComponentsBundle\AttributeReader\UploadableAttributeReaderInterface;

/**
 * Configures API Platform metadata for file resources.
 * POST /resource_short_name/upload (multipart/form-data)
 * POST /resource_short_name/{id}/upload (multipart/form-data)
 * GET  /resource_short_name/{id}/download/{property} (download file).
 *
 * @author Daniel West <[email protected]>
 */
class UploadableResourceMetadataCollectionFactory implements ResourceMetadataCollectionFactoryInterface
{
    private ResourceMetadataCollectionFactoryInterface $decorated;
    private UploadableAttributeReaderInterface $uploadableFileManager;
    private PathSegmentNameGeneratorInterface $pathSegmentNameGenerator;

    public function __construct(ResourceMetadataCollectionFactoryInterface $decorated, UploadableAttributeReaderInterface $annotationReader, PathSegmentNameGeneratorInterface $pathSegmentNameGenerator)
    {
        $this->decorated = $decorated;
        $this->uploadableFileManager = $annotationReader;
        $this->pathSegmentNameGenerator = $pathSegmentNameGenerator;
    }

    public function create(string $resourceClass): ResourceMetadataCollection
    {
        $resourceMetadata = $this->decorated->create($resourceClass);
        if (!$this->uploadableFileManager->isConfigured($resourceClass)) {
            return $resourceMetadata;
        }

        $fields = $this->uploadableFileManager->getConfiguredProperties($resourceClass, false);
        $openApiRequestMultipartProperties = [];
        foreach ($fields as $field => $configuration) {
            $openApiRequestMultipartProperties[$field] = [
                'type' => 'string',
                'format' => 'binary',
            ];
        }

        /** @var ApiResource $resourceMetadatum */
        foreach ($resourceMetadata as $resourceMetadatum) {
            $resourceShortName = $resourceMetadatum->getShortName();
            $pathSegmentName = $this->pathSegmentNameGenerator->getSegmentName($resourceShortName);
            $operations = $resourceMetadatum->getOperations();
            if (!$operations) {
                continue;
            }
            /** @var Operation $operation */
            foreach ($operations as $operation) {
                if ($operation instanceof Post) {
                    $postUploadOperation = static::generatePostOperation($operation, $openApiRequestMultipartProperties, $pathSegmentName);
                    $operations->add(self::generateOperationName($postUploadOperation), $postUploadOperation);
                }
                if ($operation instanceof Get) {
                    $uploadItemOperation = self::generateUploadItemOperation($operation, $openApiRequestMultipartProperties, $pathSegmentName);
                    $operations->add(self::generateOperationName($uploadItemOperation), $uploadItemOperation);

                    $downloadItemOperation = self::generateDownloadItemOperation($operation, $pathSegmentName);
                    $operations->add(self::generateOperationName($downloadItemOperation), $downloadItemOperation);
                }
            }
        }

        return $resourceMetadata;
    }

    #[Pure]
    private static function generateOperationName(Operation $operation): string
    {
        return sprintf(
            '_api_%s_%s%s',
            $operation->getUriTemplate(),
                        getUriTemplate(),
            strtolower($operation->getMethod()),
            strtolower($operation->/** @scrutinizer ignore-call */ getMethod()),
            $operation->isCollection() ? '_collection' : ''
                        isCollection() ? '_collection' : ''
        );
    }

    #[Pure]
    private static function configurePostOperation(Operation $postOperation, array $openApiRequestMultipartProperties): Operation
    {
        return $postOperation
            ->withController(UploadAction::class)
            ->/** @scrutinizer ignore-call */ withController(UploadAction::class)
            ->withDeserialize(false)
            ->withStateless(null)
            ->withOpenapiContext([
                'requestBody' => [
                    'content' => [
                        'multipart/form-data' => [
                            'schema' => [
                                'type' => 'object',
                                'properties' => $openApiRequestMultipartProperties,
                            ],
                        ],
                    ],
                ],
            ]);
    }

    #[Pure]
    private static function generatePostOperation(Post $defaultOperation, array $openApiRequestMultipartProperties, string $pathSegmentName): Operation
    {
        $path = sprintf('/%s/upload', $pathSegmentName);
        $newPost = $defaultOperation
            ->withUriTemplate($path)
            ->withShortName($defaultOperation->getShortName())
            ->withRoutePrefix($defaultOperation->getRoutePrefix() ?? '');

        return self::configurePostOperation($newPost, $openApiRequestMultipartProperties);
    }

    #[Pure]
    private static function generateUploadItemOperation(Get $getOperation, array $openApiRequestMultipartProperties, string $pathSegmentName): Operation
    {
        $path = sprintf('/%s/{id}/upload', $pathSegmentName);
        $newUploadPost = $getOperation
            ->withUriTemplate($path)
            ->withMethod(Operation::METHOD_POST)

            ->withShortName($getOperation->getShortName())
            ->withRoutePrefix($getOperation->getRoutePrefix() ?? '');

        return self::configurePostOperation($newUploadPost, $openApiRequestMultipartProperties);
    }

    #[Pure]
    private static function generateDownloadItemOperation(Get $getOperation, string $pathSegmentName): Operation
    {
        $downloadPath = sprintf('/%s/{id}/download/{property}', $pathSegmentName);

        return $getOperation
            ->withUriTemplate($downloadPath)
            ->withStateless(null)
            ->withController(DownloadAction::class)
            ->withSerialize(false);
    }
}

components-web-app / api-components-bundle

Pull Request — main (#139)

generateUploadItemOperation() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
