CakeDC\Api\Middleware\RequestHandlerMiddleware

Complexity

Total Complexity

18

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
B	__invoke()	0	22	5
D	requestedWith()	0	29	10
A	convertXml()	0	13	3

<?php

namespace CakeDC\Api\Middleware;

use CakeDC\Api\Service\ConfigReader;
use CakeDC\Api\Service\ServiceRegistry;
use Cake\Core\Configure;
use Cake\Http\RequestTransformer;
use Cake\Http\ResponseTransformer;
use Cake\Routing\Exception\RedirectException;
use Cake\Routing\Router;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Zend\Diactoros\Response\RedirectResponse;

/**
 * Applies routing rules to the request and creates the controller
 * instance if possible.
 */
class RequestHandlerMiddleware
{


    /**
     * Request object
     *
     * @var \Cake\Network\Request
     */
    public $request;

    /**
     * @param \Psr\Http\Message\ServerRequestInterface $request The request.
     * @param \Psr\Http\Message\ResponseInterface $response The response.
     * @param callable $next The next middleware to call.
     * @return \Psr\Http\Message\ResponseInterface A response.
     */
    public function __invoke(ServerRequestInterface $request, ResponseInterface $response, $next)
    {
        $inputTypeMap = [
            'json' => ['json_decode', true],
            'xml' => [[$this, 'convertXml']],
        ];
		$this->request = RequestTransformer::toCake($request);
		$this->response = ResponseTransformer::toCake($response);

The property response does not exist. Did you maybe forget to declare it?

		$parsedBody = $request->getParsedBody();

         foreach ($inputTypeMap as $type => $handler) {
             if (!is_callable($handler[0])) {
                 throw new RuntimeException(sprintf("Invalid callable for '%s' type.", $type));
             }
             if (empty($parsedBody) && $this->requestedWith($type)) {
                 $input = call_user_func_array([$this->request, 'input'], $handler);
                 return $next($request->withParsedBody($input), $response);
             }
         }
		
        return $next($request, $response);
    }
	

    /**
     * Determines the content type of the data the client has sent (i.e. in a POST request)
     *
     * @param string|array|null $type Can be null (or no parameter), a string type name, or an array of types
     * @return mixed If a single type is supplied a boolean will be returned. If no type is provided
     *   The mapped value of CONTENT_TYPE will be returned. If an array is supplied the first type
     *   in the request content type will be returned.
     */
    public function requestedWith($type = null)
    {
        $request = $this->request;
        if (!$request->is('post') &&
            !$request->is('put') &&
            !$request->is('patch') &&
            !$request->is('delete')
        ) {
            return null;
        }
        if (is_array($type)) {
            foreach ($type as $t) {
                if ($this->requestedWith($t)) {
                    return $t;
                }
            }

            return false;
        }

        list($contentType) = explode(';', $request->contentType());
        $response = $this->response;
        if ($type === null) {
            return $response->mapType($contentType);
        }
        if (is_string($type)) {
            return ($type === $response->mapType($contentType));
        }
    }

    /**
     * Helper method to parse xml input data, due to lack of anonymous functions
     * this lives here.
     *
     * @param string $xml XML string.
     * @return array Xml array data
     */
    public function convertXml($xml)
    {
        try {
            $xml = Xml::build($xml, ['readFile' => false]);
            if (isset($xml->data)) {
                return Xml::toArray($xml->data);
            }

            return Xml::toArray($xml);
        } catch (XmlException $e) {

The class CakeDC\Api\Middleware\XmlException does not exist. Did you forget a USE statement, or did you not list all dependencies?

            return [];
        }
    }

	
}