kalanis\Restful\Application\UI\ResourcePresenter

Complexity

Total Complexity

28

Size/Duplication

Total Lines	199
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	createErrorResource()	0	13	3
A	sendResource()	0	16	3
A	link()	0	3	1
A	checkRequirements()	0	13	3
A	beforeRender()	0	4	1
A	startup()	0	27	6
B	sendErrorResource()	0	22	7
A	getInput()	0	13	3
A	formatValidateMethod()	0	3	1

<?php

namespace kalanis\Restful\Application\UI;


use kalanis\Restful\Application\Exceptions\BadRequestException;
use kalanis\Restful\Application\IResourcePresenter;
use kalanis\Restful\Application\IResponseFactory;
use kalanis\Restful\Application\ResponseFactory;
use kalanis\Restful\Application\Responses\ErrorResponse;
use kalanis\Restful\Exceptions\InvalidStateException;
use kalanis\Restful\Http\IInput;
use kalanis\Restful\Http\Input;
use kalanis\Restful\Http\InputFactory;
use kalanis\Restful\IResource;
use kalanis\Restful\IResourceFactory;
use kalanis\Restful\Resource\Link;
use kalanis\Restful\Security\AuthenticationContext;
use kalanis\Restful\Security\Exceptions\SecurityException;
use Nette\Application;
use Nette\Application\UI;
use ReflectionClass;
use ReflectionMethod;
use Throwable;


/**
 * Base presenter for REST API presenters
 * @package kalanis\Restful\Application
 */
abstract class ResourcePresenter extends UI\Presenter implements IResourcePresenter
{

    /** @internal */
    public const VALIDATE_ACTION_PREFIX = 'validate';

    /** @var IResource|array<string, mixed>|null */
    protected mixed $resource = null;

    #[\Nette\DI\Attributes\Inject]
    public IResourceFactory $resourceFactory;

    #[\Nette\DI\Attributes\Inject]
    public IResponseFactory $responseFactory;

    #[\Nette\DI\Attributes\Inject]
    public AuthenticationContext $authentication;

    private ?IInput $input = null;

    #[\Nette\DI\Attributes\Inject]
    public InputFactory $inputFactory;

    /**
     * Check security and other presenter requirements
     * @param ReflectionClass<object>|ReflectionMethod $element
     * @return void
     */
    public function checkRequirements(ReflectionClass|ReflectionMethod $element): void
    {
        try {
            parent::checkRequirements($element);
        } catch (Application\ForbiddenRequestException $e) {
            $this->sendErrorResource($e);
        }

        // Try to authenticate client
        try {
            $this->authentication->authenticate($this->getInput());
        } catch (SecurityException $e) {
            $this->sendErrorResource($e);
        }
    }

    /**
     * Send error resource to output
     */
    protected function sendErrorResource(Throwable $e, ?string $contentType = null): void
    {
        try {
            $this->sendResponse(
                new ErrorResponse(
                    $this->responseFactory->create($this->createErrorResource($e)),
                    (99 < $e->getCode() && 600 > $e->getCode() ? $e->getCode() : 400)
                )
            );

        } catch (InvalidStateException $e) {
            // if the $contentType is not forced and the user has requested an unacceptable content-type, default to JSON
            $accept = $this->getHttpRequest()->getHeader('Accept');

            /** @var ResponseFactory $responseFactory */
            $responseFactory = $this->responseFactory;
            if (is_null($contentType) && (!$accept || !$responseFactory->isAcceptable($accept))) {
                $contentType = IResource::JSON;
            }
            $this->sendErrorResource(
                BadRequestException::unsupportedMediaType($e->getMessage(), $e),
                $contentType
            );
        }
    }

    /**
     * Create error response from exception
     * @param Throwable $e
     * @return IResource
     */
    protected function createErrorResource(Throwable $e): IResource
    {
        $params = [
            'code' => $e->getCode(),
            'status' => 'error',
            'message' => $e->getMessage(),
        ];

        if (($e instanceof BadRequestException) && !empty($e->errors)) {
            $params['errors'] = $e->errors;
        }

        return $this->resourceFactory->create($params);
    }

    /**
     * Get input
     * @return IInput
     */
    public function getInput(): IInput
    {
        if ($this->input) {
            return $this->input;
        }
        try {
            $input = $this->inputFactory->create();
            $this->input = $input;
            return $input;
        } catch (BadRequestException $e) {
            $this->sendErrorResource($e);
            // wont happen
            throw $e;
        }
    }

    /**
     * Create resource link representation object
     * @param string $destination
     * @param array<string, string>|string $args
     * @param string $rel
     * @throws UI\InvalidLinkException
     * @return string
     */
    public function link(string $destination, $args = [], $rel = Link::SELF): string
    {
        return new Link(parent::link($destination, $args), $rel);
    }

    /**
     * Presenter startup
     *
     * @throws BadRequestException
     */
    protected function startup(): void
    {
        parent::startup();
        $this->autoCanonicalize = false;

        try {
            // Create resource object
            $this->resource = $this->resourceFactory->create();

            // calls $this->validate<Action>()
            $validationProcessed = $this->tryCall(static::formatValidateMethod($this->getAction()), $this->params);

            // Check if input is validate
            $input = $this->getInput();
            /** @var Input<string, mixed> $input */
            if (!$input->isValid() && true === $validationProcessed) {
                $errors = $input->validate();
                throw BadRequestException::unprocessableEntity($errors, 'Validation Failed: ' . $errors[0]->getMessage());
            }
        } catch (BadRequestException $e) {
            if (422 === $e->getCode()) {
                $this->sendErrorResource($e);
                return;
            }
            throw $e;
        } catch (InvalidStateException $e) {
            $this->sendErrorResource($e);
        }
    }

    /**
     * Validate action method
     */
    public static function formatValidateMethod(string $action): string
    {
        return self::VALIDATE_ACTION_PREFIX . $action;
    }

    /**
     * On before render
     */
    protected function beforeRender(): void
    {
        parent::beforeRender();
        $this->sendResource();
    }

    /**
     * Get REST API response
     * @param string|null $contentType
     * @throws InvalidStateException
     */
    public function sendResource(?string $contentType = null): void
    {
        try {
            $this->sendResponse(
                $this->responseFactory->create(
                    ($this->resource instanceof IResource)
                        ? $this->resource
                        : $this->resourceFactory->create((array) $this->resource)
                    ,
                    $contentType,
                )
            );
        } catch (InvalidStateException $e) {
            $this->sendErrorResource(
                BadRequestException::unsupportedMediaType($e->getMessage(), $e),
                $contentType,
            );
        }
    }
}