PaginationPlugin::onPostCreateResponse() - Code Metrics - Inspection of "Pagination added to all data layers" - pjordaan/apie - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Branch — v4 (4e54dd)

by Pieter
created 2020-08-21 13:36 UTC
PaginationPlugin::onPostCreateResponse() B

↳ Parent: PaginationPlugin
Complexity

Conditions	7
Paths	14
Size

Total Lines	27
Code Lines	20
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	1
Metric	Value
cc	7
eloc	20
nc	14
nop	1
dl	0
loc	27
rs	8.6666
c	1
b	0
f	1
<?php

namespace W2w\Lib\Apie\Plugins\Pagination;

use erasys\OpenApi\Spec\v3\Document;
use erasys\OpenApi\Spec\v3\Header;
use erasys\OpenApi\Spec\v3\Operation;
use erasys\OpenApi\Spec\v3\PathItem;
use erasys\OpenApi\Spec\v3\Reference;
use Pagerfanta\Adapter\AdapterInterface;
use Pagerfanta\Adapter\ArrayAdapter;
use Pagerfanta\Pagerfanta;
use W2w\Lib\Apie\Core\SearchFilters\SearchFilterHelper;
use W2w\Lib\Apie\Events\DecodeEvent;
use W2w\Lib\Apie\Events\DeleteResourceEvent;
use W2w\Lib\Apie\Events\ModifySingleResourceEvent;
use W2w\Lib\Apie\Events\NormalizeEvent;
use W2w\Lib\Apie\Events\ResponseAllEvent;
use W2w\Lib\Apie\Events\ResponseEvent;
use W2w\Lib\Apie\Events\RetrievePaginatedResourcesEvent;
use W2w\Lib\Apie\Events\RetrieveSingleResourceEvent;
use W2w\Lib\Apie\Events\StoreExistingResourceEvent;
use W2w\Lib\Apie\Events\StoreNewResourceEvent;
use W2w\Lib\Apie\PluginInterfaces\ApieAwareInterface;
use W2w\Lib\Apie\PluginInterfaces\ApieAwareTrait;
use W2w\Lib\Apie\PluginInterfaces\NormalizerProviderInterface;
use W2w\Lib\Apie\PluginInterfaces\OpenApiEventProviderInterface;
use W2w\Lib\Apie\PluginInterfaces\ResourceLifeCycleInterface;
use W2w\Lib\Apie\Plugins\Pagination\Normalizers\PaginatorNormalizer;

class PaginationPlugin implements ResourceLifeCycleInterface, NormalizerProviderInterface, OpenApiEventProviderInterface, ApieAwareInterface
{
    use ApieAwareTrait;

    const PREV_HEADER = 'x-pagination-previous';

    const NEXT_HEADER = 'x-pagination-next';

    const FIRST_HEADER = 'x-pagination-first';

    const LAST_HEADER = 'x-pagination-last';

    const COUNT_HEADER = 'x-pagination-count';

    public function getNormalizers(): array
    {
        return [new PaginatorNormalizer()];
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    public function onOpenApiDocGenerated(Document $document): Document
    {
        /** @var PathItem[] $paths */
        $paths = $document->paths ?? [];
        foreach ($paths as $url => $path) {
            if (strpos($url, '{id}', 0) === false && $path->get) {
                $this->patch($path->get);
            }
        }
        return $document;
    }

    private function patch(Operation $operation): Operation
    {
        foreach ($operation->responses as &$response) {
            if ($response instanceof Reference) {
                continue;
            }
            $response->headers[self::PREV_HEADER] = new Header('Pagination previous page url', []);
            $response->headers[self::NEXT_HEADER] = new Header('Pagination next page url', []);
            $response->headers[self::FIRST_HEADER] = new Header('Pagination first page url', []);
            $response->headers[self::LAST_HEADER] = new Header('Pagination last page url', []);
        }
        return $operation;
    }

    public function onPreDeleteResource(DeleteResourceEvent $event)
    {
    }

    public function onPostDeleteResource(DeleteResourceEvent $event)
    {
    }

    public function onPreRetrieveResource(RetrieveSingleResourceEvent $event)
    {
    }

    public function onPostRetrieveResource(RetrieveSingleResourceEvent $event)
    {
    }

    public function onPreRetrieveAllResources(RetrievePaginatedResourcesEvent $event)
    {
    }

    public function onPostRetrieveAllResources(RetrievePaginatedResourcesEvent $event)
    {
    }

    public function onPrePersistExistingResource(StoreExistingResourceEvent $event)
    {
    }

    public function onPostPersistExistingResource(StoreExistingResourceEvent $event)
    {
    }

    public function onPreDecodeRequestBody(DecodeEvent $event)
    {
    }

    public function onPostDecodeRequestBody(DecodeEvent $event)
    {
    }

    public function onPreModifyResource(ModifySingleResourceEvent $event)
    {
    }

    public function onPostModifyResource(ModifySingleResourceEvent $event)
    {
    }

    public function onPreCreateResource(StoreNewResourceEvent $event)
    {
    }

    public function onPostCreateResource(StoreNewResourceEvent $event)
    {
    }

    public function onPrePersistNewResource(StoreExistingResourceEvent $event)
    {
    }

    public function onPostPersistNewResource(StoreExistingResourceEvent $event)
    {
    }

    public function onPreCreateResponse(ResponseEvent $event)
    {
    }

    public function onPostCreateResponse(ResponseEvent $event)
    {
        if (!($event instanceof ResponseAllEvent)) {
            return;
        }
        $resource = $event->getResource();
        if (!($resource instanceof Pagerfanta)) {
            if (is_array($resource)) {
                $resource = new Pagerfanta(new ArrayAdapter($resource));
            } else if (is_iterable($resource)) {
                $resource = new Pagerfanta(new ArrayAdapter(iterator_to_array($resource)));
            } else {
                return;
            }
            $event->getSearchFilterRequest()->updatePaginator($resource);
        }
        $response = $event->getResponse()
            ->withHeader(self::FIRST_HEADER, $this->generateUrl($event, 0))
            ->withHeader(self::LAST_HEADER, $this->generateUrl($event, $resource->getNbPages() - 1))
            ->withHeader(self::COUNT_HEADER, $this->generateUrl($event, $resource->getNbPages()));
        if ($resource->hasPreviousPage()) {
            $response = $response->withHeader(self::PREV_HEADER, $this->generateUrl($event, $resource->getPreviousPage()));
        }
        if ($resource->hasNextPage()) {
            $response = $response->withHeader(self::NEXT_HEADER, $this->generateUrl($event, $resource->getNextPage()));
        }
        $event->setResponse($response);
        $event->setResponse(/** @scrutinizer ignore-type */ $response);
    }

    private function generateUrl(ResponseAllEvent  $event, int $page)
    {
        $baseUrl = $this->getApie()->getOverviewUrlForResourceClass($event->getResourceClass(), $event->getSearchFilterRequest());
        return $baseUrl . '?' . http_build_query(['page' => $page, 'limit' => $event->getSearchFilterRequest()->getNumberOfItems()]);
    }

    public function onPreCreateNormalizedData(NormalizeEvent $event)
    {
    }

    public function onPostCreateNormalizedData(NormalizeEvent $event)
    {
    }
}

pjordaan / apie

Branch — v4 (4e54dd)

PaginationPlugin::onPostCreateResponse() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
