Fesor\RequestObject\RequestObjectBinder

Complexity

Total Complexity

20

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	providerErrorResponse()	0	12	3
B	bind()	0	30	5
C	matchActionArguments()	0	26	7
A	resolvePayload()	0	8	2
A	isArgumentIsSubtypeOf()	0	8	2

<?php

namespace Fesor\RequestObject;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;

class RequestObjectBinder
{
    /**
     * @var ValidatorInterface
     */
    private $validator;

    /**
     * @var PayloadResolver
     */
    private $payloadResolver;

    /**
     * @var ErrorResponseProvider|null
     */
    private $errorResponseProvider;

    /**
     * RequestObjectBinder constructor.
     *
     * @param PayloadResolver            $payloadResolver
     * @param ValidatorInterface         $validator
     * @param ErrorResponseProvider|null $errorResponseProvider
     */
    public function __construct(
        PayloadResolver $payloadResolver,
        ValidatorInterface $validator,
        ErrorResponseProvider $errorResponseProvider = null
    ) {
        $this->validator = $validator;
        $this->payloadResolver = $payloadResolver;
        $this->errorResponseProvider = $errorResponseProvider;
    }

    /**
     * @param Request  $request
     * @param callable $action
     *
     * @return Response|void
     */
    public function bind(Request $request, callable $action)
    {
        $matchedArguments = $this->matchActionArguments($action);
        if (!array_key_exists('requestObject', $matchedArguments)) {
            return;
        }

        $requestObjectClass = $matchedArguments['requestObject']->getClass()->name;
        /** @var RequestObject $requestObject */
        $requestObject = new $requestObjectClass();
        $request->attributes->set(
            $matchedArguments['requestObject']->name,
            $requestObject
        );

        $payload = $this->resolvePayload($requestObject, $request);

        $errors = $this->validator->validate(
            $payload,
            $requestObject->rules(),
            $requestObject->validationGroup($payload)
        );

        $requestObject->setPayload($payload);
        if (array_key_exists('errors', $matchedArguments)) {
            $request->attributes->set($matchedArguments['errors']->name, $errors);
        } elseif ($errors && 0 !== $errors->count()) {
            return $this->providerErrorResponse($requestObject, $errors);
        }
    }

    /**
     * @param RequestObject                    $requestObject
     * @param ConstraintViolationListInterface $errors
     *
     * @return Response
     *
     * @throws InvalidRequestPayloadException
     */
    private function providerErrorResponse(RequestObject $requestObject, ConstraintViolationListInterface $errors)
    {
        if ($requestObject instanceof ErrorResponseProvider) {
            return $requestObject->getErrorResponse($errors);
        }

        if ($this->errorResponseProvider) {
            return $this->errorResponseProvider->getErrorResponse($errors);
        }

        throw new InvalidRequestPayloadException($requestObject, $errors);
    }

    /**
     * @param callable $action
     *
     * @return array
     */
    private function matchActionArguments(callable $action)
    {
        if (is_array($action)) {
            $classReflection = new \ReflectionClass($action[0]);
            $actionReflection = $classReflection->getMethod($action[1]);
        } elseif ($action instanceof \Closure || is_string($action)) {
            $actionReflection = new \ReflectionFunction($action);
        }
        else {
            $classReflection = new \ReflectionClass($action);
            $actionReflection = $classReflection->getMethod('__invoke');
        }

        $matchedArguments = [];
        $arguments = $actionReflection->getParameters();
        foreach ($arguments as $argument) {
            if ($this->isArgumentIsSubtypeOf($argument, RequestObject::class)) {
                $matchedArguments['requestObject'] = $argument;
            }
            if ($this->isArgumentIsSubtypeOf($argument, ConstraintViolationListInterface::class)) {
                $matchedArguments['errors'] = $argument;
            }
        }

        return $matchedArguments;
    }

    private function resolvePayload(RequestObject $requestObject, Request $request)
    {
        if ($requestObject instanceof PayloadResolver) {
            return $requestObject->resolvePayload($request);
        }

        return $this->payloadResolver->resolvePayload($request);
    }

    /**
     * @param \ReflectionParameter $argument
     * @param string               $subtype
     *
     * @return bool
     */
    private function isArgumentIsSubtypeOf(\ReflectionParameter $argument, $subtype)
    {
        if (!($className = $argument->getClass())) {
            return false;
        }

        return is_a($className->name, $subtype, true);
    }
}