ServerRequestHandler::getMethodHandler() - Code Metrics - Inspection of "Added support to OpenApi 3.0.0" - byjg/restserver - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#8)

by Joao

created 2019-12-08 18:50 UTC

ServerRequestHandler::getMethodHandler() B

↳ Parent: ServerRequestHandler

Complexity

Conditions	7
Paths	13

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	27
rs	8.5546
c	0
b	0
f	0
cc	7
nc	13
nop	3

<?php

namespace ByJG\RestServer;

use ByJG\Cache\Psr16\NoCacheEngine;
use ByJG\RestServer\Exception\ClassNotFoundException;
use ByJG\RestServer\Exception\Error404Exception;
use ByJG\RestServer\Exception\Error405Exception;
use ByJG\RestServer\Exception\Error520Exception;
use ByJG\RestServer\Exception\InvalidClassException;
use ByJG\RestServer\Exception\OperationIdInvalidException;
use ByJG\RestServer\Exception\SchemaInvalidException;
use ByJG\RestServer\Exception\SchemaNotFoundException;
use ByJG\RestServer\HandleOutput\HandleOutputInterface;
use ByJG\RestServer\HandleOutput\HtmlHandler;
use ByJG\RestServer\HandleOutput\JsonHandler;
use ByJG\RestServer\HandleOutput\XmlHandler;
use Closure;
use FastRoute\Dispatcher;
use FastRoute\RouteCollector;
use Psr\SimpleCache\CacheInterface;
use Psr\SimpleCache\InvalidArgumentException;
use function FastRoute\simpleDispatcher;

class ServerRequestHandler
{
    const OK = "OK";
    const METHOD_NOT_ALLOWED = "NOT_ALLOWED";
    const NOT_FOUND = "NOT FOUND";

    protected $routes = null;

    protected $defaultHandler = null;

    protected $mimeTypeHandler = [
        "text/xml" => XmlHandler::class,
        "application/xml" => XmlHandler::class,
        "text/html" => HtmlHandler::class,
        "application/json" => JsonHandler::class
    ];

    protected $pathHandler = [

    ];

    public function getRoutes()
    {
        return $this->routes;
    }

    /**
     * @param RoutePattern[] $routes
     */
    public function setRoutes($routes)
    {
        foreach ((array)$routes as $route) {
            $this->addRoute($route);
        }
    }

    /**
     * @param RoutePattern $route
     */
    public function addRoute(RoutePattern $route)
    {
        if (is_null($this->routes)) {
            $this->routes = [];
        }
        $this->routes[] = $route;
    }

    /**
     * @return HandleOutputInterface
     */
    public function getDefaultHandler()
    {
        if (empty($this->defaultHandler)) {
            $this->defaultHandler = new JsonHandler();
        }
        return $this->defaultHandler;
    }

    /**
     * @param HandleOutputInterface $defaultHandler
     */
    public function setDefaultHandler(HandleOutputInterface $defaultHandler)
    {
        $this->defaultHandler = $defaultHandler;
    }

    /**
     * @throws ClassNotFoundException
     * @throws Error404Exception
     * @throws Error405Exception
     * @throws Error520Exception
     * @throws InvalidClassException
     */
    protected function process()
    {
        // Initialize ErrorHandler with default error handler
        ErrorHandler::getInstance()->register();

        // Get the URL parameters
        $httpMethod = $_SERVER['REQUEST_METHOD'];
        $uri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
        parse_str(parse_url($_SERVER['REQUEST_URI'], PHP_URL_QUERY), $queryStr);

        // Generic Dispatcher for RestServer
        $dispatcher = simpleDispatcher(function (RouteCollector $r) {

            foreach ($this->getRoutes() as $route) {
                $r->addRoute(
                    $route->properties('method'),
                    $route->properties('pattern'),
                    [
                        "handler" => $route->properties('handler'),
                        "class" => $route->properties('class'),
                        "function" => $route->properties('function')
                    ]
                );
            }
        });

        $routeInfo = $dispatcher->dispatch($httpMethod, $uri);
<?php

function getDate($date)
{
    if ($date !== null) {
        return new DateTime($date);
    }

    return false;
}

        // Default Handler for errors
        $this->getDefaultHandler()->writeHeader();
        ErrorHandler::getInstance()->setHandler($this->getDefaultHandler()->getErrorHandler());

        // Processing
        switch ($routeInfo[0]) {
            case Dispatcher::NOT_FOUND:
                throw new Error404Exception("404 Route '$uri' Not found");

            case Dispatcher::METHOD_NOT_ALLOWED:
                throw new Error405Exception('405 Method Not Allowed');

            case Dispatcher::FOUND:
                // ... 200 Process:
                $vars = array_merge($routeInfo[2], $queryStr);

                // Instantiate the Service Handler
                $handlerRequest = $routeInfo[1];

                // Execute the request
                $handler = !empty($handlerRequest['handler']) ? $handlerRequest['handler'] : $this->getDefaultHandler();
                $this->executeRequest(
                    new $handler(),
                    $handlerRequest['class'],
                    $handlerRequest['function'],
                    $vars
                );

                break;

            default:
                throw new Error520Exception('Unknown');
        }
    }

    /**
     * @param HandleOutputInterface $handler
     * @param string $class
     * @param string $function
     * @param array $vars
     * @throws ClassNotFoundException
     * @throws InvalidClassException
     */
    protected function executeRequest($handler, $class, $function, $vars)
    {
        // Setting Default Headers and Error Handler
        $handler->writeHeader();
        ErrorHandler::getInstance()->setHandler($handler->getErrorHandler());

        // Set all default values
        foreach (array_keys($vars) as $key) {
            $_REQUEST[$key] = $_GET[$key] = $vars[$key];
        }

        // Create the Request and Response methods
        $request = new HttpRequest($_GET, $_POST, $_SERVER, isset($_SESSION) ? $_SESSION : [], $_COOKIE);
        $response = new HttpResponse();

        // Process Closure
        if ($function instanceof Closure) {
            $function($response, $request);
            echo $handler->processResponse($response);
            return;
        }

        // Process Class::Method()
        if (!class_exists($class)) {
            throw new ClassNotFoundException("Class '$class' defined in the route is not found");
        }
        $instance = new $class();
        if (!method_exists($instance, $function)) {
            throw new InvalidClassException("There is no method '$class::$function''");
        }
        $instance->$function($response, $request);
        $handler->processResponse($response);
    }

    /**
     * Handle the ROUTE (see web/app-dist.php)
     *
     * @param RoutePattern[]|null $routePattern
     * @param bool $outputBuffer
     * @param bool $session
     * @return bool|void
     * @throws ClassNotFoundException
     * @throws Error404Exception
     * @throws Error405Exception
     * @throws Error520Exception
     * @throws InvalidClassException
     */
    public function handle($routePattern = null, $outputBuffer = true, $session = true)
    {
        if ($outputBuffer) {
            ob_start();
        }
        if ($session) {
            session_start();
        }

        /**
         * @var ServerRequestHandler
         */
        $this->setRoutes($routePattern);


        // --------------------------------------------------------------------------
        // Check if script exists or if is itself
        // --------------------------------------------------------------------------

        $debugBacktrace =  debug_backtrace();
        if (!empty($_SERVER['SCRIPT_FILENAME'])
            && file_exists($_SERVER['SCRIPT_FILENAME'])
            && basename($_SERVER['SCRIPT_FILENAME']) !== basename($debugBacktrace[0]['file'])
        ) {
            $file = $_SERVER['SCRIPT_FILENAME'];
            if (strrchr($file, '.') === ".php") {
                require_once($file);
            } else {
                if (!defined("RESTSERVER_TEST")) {
                    header("Content-Type: " . $this->mimeContentType($file));
                }

                echo file_get_contents($file);
            }
            return true;
        }

        return $this->process();
    }

    /**
     * Get the Mime Type based on the filename
     *
     * @param string $filename
     * @return string
     * @throws Error404Exception
     */
    public function mimeContentType($filename)
    {

        $mimeTypes = array(
            'txt' => 'text/plain',
            'htm' => 'text/html',
            'html' => 'text/html',
            'php' => 'text/html',
            'css' => 'text/css',
            'js' => 'application/javascript',
            'json' => 'application/json',
            'xml' => 'application/xml',
            'swf' => 'application/x-shockwave-flash',
            'flv' => 'video/x-flv',
            // images
            'png' => 'image/png',
            'jpe' => 'image/jpeg',
            'jpeg' => 'image/jpeg',
            'jpg' => 'image/jpeg',
            'gif' => 'image/gif',
            'bmp' => 'image/bmp',
            'ico' => 'image/vnd.microsoft.icon',
            'tiff' => 'image/tiff',
            'tif' => 'image/tiff',
            'svg' => 'image/svg+xml',
            'svgz' => 'image/svg+xml',
            // archives
            'zip' => 'application/zip',
            'rar' => 'application/x-rar-compressed',
            'exe' => 'application/x-msdownload',
            'msi' => 'application/x-msdownload',
            'cab' => 'application/vnd.ms-cab-compressed',
            // audio/video
            'mp3' => 'audio/mpeg',
            'qt' => 'video/quicktime',
            'mov' => 'video/quicktime',
            // adobe
            'pdf' => 'application/pdf',
            'psd' => 'image/vnd.adobe.photoshop',
            'ai' => 'application/postscript',
            'eps' => 'application/postscript',
            'ps' => 'application/postscript',
            // ms office
            'doc' => 'application/msword',
            'rtf' => 'application/rtf',
            'xls' => 'application/vnd.ms-excel',
            'ppt' => 'application/vnd.ms-powerpoint',
            // open office
            'odt' => 'application/vnd.oasis.opendocument.text',
            'ods' => 'application/vnd.oasis.opendocument.spreadsheet',
        );

        if (!file_exists($filename)) {
            throw new Error404Exception();
        }

        $ext = substr(strrchr($filename, "."), 1);
        if (array_key_exists($ext, $mimeTypes)) {
            return $mimeTypes[$ext];
        } elseif (function_exists('finfo_open')) {
            $finfo = finfo_open(FILEINFO_MIME);
            $mimetype = finfo_file($finfo, $filename);
            finfo_close($finfo);
            return $mimetype;
        } else {
            return 'application/octet-stream';
        }
    }

    /**
     * @param $swaggerJson
     * @param CacheInterface|null $cache
     * @throws SchemaInvalidException
     * @throws SchemaNotFoundException
     * @throws OperationIdInvalidException
     * @throws InvalidArgumentException
     */
    public function setRoutesSwagger($swaggerJson, CacheInterface $cache = null)
    {
        $swaggerWrapper = new SwaggerWrapper($swaggerJson, $this);

        if (is_null($cache)) {
            $cache = new NoCacheEngine();
        }

        $routePattern = $cache->get('SERVERHANDLERROUTES', false);
        if ($routePattern === false) {
            $routePattern = $swaggerWrapper->generateRoutes();
            $cache->set('SERVERHANDLERROUTES', $routePattern);
        }
        $this->setRoutes($routePattern);
    }

    public function setMimeTypeHandler($mimetype, $handler)
    {
        $this->mimeTypeHandler[$mimetype] = $handler;
    }

    public function setPathHandler($method, $path, $handler)
    {
        $method = strtoupper($method);
        $this->pathHandler["$method::$path"] = $handler;
    }

    /**
     * @param $method
     * @param $path
     * @param $properties
     * @return string
     * @throws OperationIdInvalidException
     */
    public function getMethodHandler($method, $path, $properties)
    {
        $method = strtoupper($method);
        if (isset($this->pathHandler["$method::$path"])) {
            return $this->pathHandler["$method::$path"];
        }

        $produces = null;
        if (isset($properties['produces'])) {
            $produces = (array) $properties['produces'];
        }
        if (empty($produces) && isset($properties["responses"]["200"]["content"])) {
            $produces = array_keys($properties["responses"]["200"]["content"]);
        }

        if (empty($produces)) {
            return get_class($this->getDefaultHandler());
        }

        $produces = $produces[0];

        if (!isset($this->mimeTypeHandler[$produces])) {
            throw new OperationIdInvalidException("There is no handler for $produces");
        }

        return $this->mimeTypeHandler[$produces];
    }
}


1			<?php
2
3			namespace ByJG\RestServer;
4
5			use ByJG\Cache\Psr16\NoCacheEngine;
6			use ByJG\RestServer\Exception\ClassNotFoundException;
7			use ByJG\RestServer\Exception\Error404Exception;
8			use ByJG\RestServer\Exception\Error405Exception;
9			use ByJG\RestServer\Exception\Error520Exception;
10			use ByJG\RestServer\Exception\InvalidClassException;
11			use ByJG\RestServer\Exception\OperationIdInvalidException;
12			use ByJG\RestServer\Exception\SchemaInvalidException;
13			use ByJG\RestServer\Exception\SchemaNotFoundException;
14			use ByJG\RestServer\HandleOutput\HandleOutputInterface;
15			use ByJG\RestServer\HandleOutput\HtmlHandler;
16			use ByJG\RestServer\HandleOutput\JsonHandler;
17			use ByJG\RestServer\HandleOutput\XmlHandler;
18			use Closure;
19			use FastRoute\Dispatcher;
20			use FastRoute\RouteCollector;
21			use Psr\SimpleCache\CacheInterface;
22			use Psr\SimpleCache\InvalidArgumentException;
23			use function FastRoute\simpleDispatcher;
24
25			class ServerRequestHandler
26			{
27			const OK = "OK";
28			const METHOD_NOT_ALLOWED = "NOT_ALLOWED";
29			const NOT_FOUND = "NOT FOUND";
30
31			protected $routes = null;
32
33			protected $defaultHandler = null;
34
35			protected $mimeTypeHandler = [
36			"text/xml" => XmlHandler::class,
37			"application/xml" => XmlHandler::class,
38			"text/html" => HtmlHandler::class,
39			"application/json" => JsonHandler::class
40			];
41
42			protected $pathHandler = [
43
44			];
45
46			public function getRoutes()
47			{
48			return $this->routes;
49			}
50
51			/**
52			* @param RoutePattern[] $routes
53			*/
54			public function setRoutes($routes)
55			{
56			foreach ((array)$routes as $route) {
57			$this->addRoute($route);
58			}
59			}
60
61			/**
62			* @param RoutePattern $route
63			*/
64			public function addRoute(RoutePattern $route)
65			{
66			if (is_null($this->routes)) {
67			$this->routes = [];
68			}
69			$this->routes[] = $route;
70			}
71
72			/**
73			* @return HandleOutputInterface
74			*/
75			public function getDefaultHandler()
76			{
77			if (empty($this->defaultHandler)) {
78			$this->defaultHandler = new JsonHandler();
79			}
80			return $this->defaultHandler;
81			}
82
83			/**
84			* @param HandleOutputInterface $defaultHandler
85			*/
86			public function setDefaultHandler(HandleOutputInterface $defaultHandler)
87			{
88			$this->defaultHandler = $defaultHandler;
89			}
90
91			/**
92			* @throws ClassNotFoundException
93			* @throws Error404Exception
94			* @throws Error405Exception
95			* @throws Error520Exception
96			* @throws InvalidClassException
97			*/
98			protected function process()
99			{
100			// Initialize ErrorHandler with default error handler
101			ErrorHandler::getInstance()->register();
102
103			// Get the URL parameters
104			$httpMethod = $_SERVER['REQUEST_METHOD'];
105			$uri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
106			parse_str(parse_url($_SERVER['REQUEST_URI'], PHP_URL_QUERY), $queryStr);
107
108			// Generic Dispatcher for RestServer
109			$dispatcher = simpleDispatcher(function (RouteCollector $r) {
110
111			foreach ($this->getRoutes() as $route) {
112			$r->addRoute(
113			$route->properties('method'),
114			$route->properties('pattern'),
115			[
116			"handler" => $route->properties('handler'),
117			"class" => $route->properties('class'),
118			"function" => $route->properties('function')
119			]
120			);
121			}
122			});
123
124			$routeInfo = $dispatcher->dispatch($httpMethod, $uri);
			0 ignored issues – show Security Bug introduced 2016-02-04 17:48 UTC by Report Bug Copy Issue Report It seems like `$uri` defined by `parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH)` on line `105` can also be of type `false`; however, `FastRoute\Dispatcher::dispatch()` does only seem to accept `string`, did you maybe forget to handle an error condition? This check looks for type mismatches where the missing type is `false`. This is usually indicative of an error condtion. Consider the follow example <?php function getDate($date) { if ($date !== null) { return new DateTime($date); } return false; } This function either returns a new `DateTime` object or false, if there was an error. This is a typical pattern in PHP programming to show that an error has occurred without raising an exception. The calling code should check for this returned `false` before passing on the value to another function or method that may not be able to handle a `false`. Loading history...
125
126			// Default Handler for errors
127			$this->getDefaultHandler()->writeHeader();
128			ErrorHandler::getInstance()->setHandler($this->getDefaultHandler()->getErrorHandler());
129
130			// Processing
131			switch ($routeInfo[0]) {
132			case Dispatcher::NOT_FOUND:
133			throw new Error404Exception("404 Route '$uri' Not found");
134
135			case Dispatcher::METHOD_NOT_ALLOWED:
136			throw new Error405Exception('405 Method Not Allowed');
137
138			case Dispatcher::FOUND:
139			// ... 200 Process:
140			$vars = array_merge($routeInfo[2], $queryStr);
141
142			// Instantiate the Service Handler
143			$handlerRequest = $routeInfo[1];
144
145			// Execute the request
146			$handler = !empty($handlerRequest['handler']) ? $handlerRequest['handler'] : $this->getDefaultHandler();
147			$this->executeRequest(
148			new $handler(),
149			$handlerRequest['class'],
150			$handlerRequest['function'],
151			$vars
152			);
153
154			break;
155
156			default:
157			throw new Error520Exception('Unknown');
158			}
159			}
160
161			/**
162			* @param HandleOutputInterface $handler
163			* @param string $class
164			* @param string $function
165			* @param array $vars
166			* @throws ClassNotFoundException
167			* @throws InvalidClassException
168			*/
169			protected function executeRequest($handler, $class, $function, $vars)
170			{
171			// Setting Default Headers and Error Handler
172			$handler->writeHeader();
173			ErrorHandler::getInstance()->setHandler($handler->getErrorHandler());
174
175			// Set all default values
176			foreach (array_keys($vars) as $key) {
177			$_REQUEST[$key] = $_GET[$key] = $vars[$key];
178			}
179
180			// Create the Request and Response methods
181			$request = new HttpRequest($_GET, $_POST, $_SERVER, isset($_SESSION) ? $_SESSION : [], $_COOKIE);
182			$response = new HttpResponse();
183
184			// Process Closure
185			if ($function instanceof Closure) {
186			$function($response, $request);
187			echo $handler->processResponse($response);
188			return;
189			}
190
191			// Process Class::Method()
192			if (!class_exists($class)) {
193			throw new ClassNotFoundException("Class '$class' defined in the route is not found");
194			}
195			$instance = new $class();
196			if (!method_exists($instance, $function)) {
197			throw new InvalidClassException("There is no method '$class::$function''");
198			}
199			$instance->$function($response, $request);
200			$handler->processResponse($response);
201			}
202
203			/**
204			* Handle the ROUTE (see web/app-dist.php)
205			*
206			* @param RoutePattern[]\|null $routePattern
207			* @param bool $outputBuffer
208			* @param bool $session
209			* @return bool\|void
210			* @throws ClassNotFoundException
211			* @throws Error404Exception
212			* @throws Error405Exception
213			* @throws Error520Exception
214			* @throws InvalidClassException
215			*/
216			public function handle($routePattern = null, $outputBuffer = true, $session = true)
217			{
218			if ($outputBuffer) {
219			ob_start();
220			}
221			if ($session) {
222			session_start();
223			}
224
225			/**
226			* @var ServerRequestHandler
227			*/
228			$this->setRoutes($routePattern);
			0 ignored issues – show Bug introduced 2018-01-30 14:24 UTC by Report Bug Copy Issue Report It seems like `$routePattern` defined by parameter `$routePattern` on line 216 can also be of type `null`; however, `ByJG\RestServer\ServerRequestHandler::setRoutes()` does only seem to accept `array<integer,object<ByJ...stServer\RoutePattern>>`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
229
230			// --------------------------------------------------------------------------
231			// Check if script exists or if is itself
232			// --------------------------------------------------------------------------
233
234			$debugBacktrace = debug_backtrace();
235			if (!empty($_SERVER['SCRIPT_FILENAME'])
236			&& file_exists($_SERVER['SCRIPT_FILENAME'])
237			&& basename($_SERVER['SCRIPT_FILENAME']) !== basename($debugBacktrace[0]['file'])
238			) {
239			$file = $_SERVER['SCRIPT_FILENAME'];
240			if (strrchr($file, '.') === ".php") {
241			require_once($file);
242			} else {
243			if (!defined("RESTSERVER_TEST")) {
244			header("Content-Type: " . $this->mimeContentType($file));
245			}
246
247			echo file_get_contents($file);
248			}
249			return true;
250			}
251
252			return $this->process();
253			}
254
255			/**
256			* Get the Mime Type based on the filename
257			*
258			* @param string $filename
259			* @return string
260			* @throws Error404Exception
261			*/
262			public function mimeContentType($filename)
263			{
264
265			$mimeTypes = array(
266			'txt' => 'text/plain',
267			'htm' => 'text/html',
268			'html' => 'text/html',
269			'php' => 'text/html',
270			'css' => 'text/css',
271			'js' => 'application/javascript',
272			'json' => 'application/json',
273			'xml' => 'application/xml',
274			'swf' => 'application/x-shockwave-flash',
275			'flv' => 'video/x-flv',
276			// images
277			'png' => 'image/png',
278			'jpe' => 'image/jpeg',
279			'jpeg' => 'image/jpeg',
280			'jpg' => 'image/jpeg',
281			'gif' => 'image/gif',
282			'bmp' => 'image/bmp',
283			'ico' => 'image/vnd.microsoft.icon',
284			'tiff' => 'image/tiff',
285			'tif' => 'image/tiff',
286			'svg' => 'image/svg+xml',
287			'svgz' => 'image/svg+xml',
288			// archives
289			'zip' => 'application/zip',
290			'rar' => 'application/x-rar-compressed',
291			'exe' => 'application/x-msdownload',
292			'msi' => 'application/x-msdownload',
293			'cab' => 'application/vnd.ms-cab-compressed',
294			// audio/video
295			'mp3' => 'audio/mpeg',
296			'qt' => 'video/quicktime',
297			'mov' => 'video/quicktime',
298			// adobe
299			'pdf' => 'application/pdf',
300			'psd' => 'image/vnd.adobe.photoshop',
301			'ai' => 'application/postscript',
302			'eps' => 'application/postscript',
303			'ps' => 'application/postscript',
304			// ms office
305			'doc' => 'application/msword',
306			'rtf' => 'application/rtf',
307			'xls' => 'application/vnd.ms-excel',
308			'ppt' => 'application/vnd.ms-powerpoint',
309			// open office
310			'odt' => 'application/vnd.oasis.opendocument.text',
311			'ods' => 'application/vnd.oasis.opendocument.spreadsheet',
312			);
313
314			if (!file_exists($filename)) {
315			throw new Error404Exception();
316			}
317
318			$ext = substr(strrchr($filename, "."), 1);
319			if (array_key_exists($ext, $mimeTypes)) {
320			return $mimeTypes[$ext];
321			} elseif (function_exists('finfo_open')) {
322			$finfo = finfo_open(FILEINFO_MIME);
323			$mimetype = finfo_file($finfo, $filename);
324			finfo_close($finfo);
325			return $mimetype;
326			} else {
327			return 'application/octet-stream';
328			}
329			}
330
331			/**
332			* @param $swaggerJson
333			* @param CacheInterface\|null $cache
334			* @throws SchemaInvalidException
335			* @throws SchemaNotFoundException
336			* @throws OperationIdInvalidException
337			* @throws InvalidArgumentException
338			*/
339			public function setRoutesSwagger($swaggerJson, CacheInterface $cache = null)
340			{
341			$swaggerWrapper = new SwaggerWrapper($swaggerJson, $this);
342
343			if (is_null($cache)) {
344			$cache = new NoCacheEngine();
345			}
346
347			$routePattern = $cache->get('SERVERHANDLERROUTES', false);
348			if ($routePattern === false) {
349			$routePattern = $swaggerWrapper->generateRoutes();
350			$cache->set('SERVERHANDLERROUTES', $routePattern);
351			}
352			$this->setRoutes($routePattern);
353			}
354
355			public function setMimeTypeHandler($mimetype, $handler)
356			{
357			$this->mimeTypeHandler[$mimetype] = $handler;
358			}
359
360			public function setPathHandler($method, $path, $handler)
361			{
362			$method = strtoupper($method);
363			$this->pathHandler["$method::$path"] = $handler;
364			}
365
366			/**
367			* @param $method
368			* @param $path
369			* @param $properties
370			* @return string
371			* @throws OperationIdInvalidException
372			*/
373			public function getMethodHandler($method, $path, $properties)
374			{
375			$method = strtoupper($method);
376			if (isset($this->pathHandler["$method::$path"])) {
377			return $this->pathHandler["$method::$path"];
378			}
379
380			$produces = null;
381			if (isset($properties['produces'])) {
382			$produces = (array) $properties['produces'];
383			}
384			if (empty($produces) && isset($properties["responses"]["200"]["content"])) {
385			$produces = array_keys($properties["responses"]["200"]["content"]);
386			}
387
388			if (empty($produces)) {
389			return get_class($this->getDefaultHandler());
390			}
391
392			$produces = $produces[0];
393
394			if (!isset($this->mimeTypeHandler[$produces])) {
395			throw new OperationIdInvalidException("There is no handler for $produces");
396			}
397
398			return $this->mimeTypeHandler[$produces];
399			}
400			}
401

byjg / restserver

Pull Request — master (#8)

ServerRequestHandler::getMethodHandler() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like