ServerRequestHandler::setPathHandler() - Code Metrics - Inspection of "Fix swagger to get base" - byjg/restserver - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 382c30...1fdbd5 )

by Joao

created 2019-04-11 03:19 UTC

ServerRequestHandler::setPathHandler() A

↳ Parent: ServerRequestHandler

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	5
rs	10
c	0
b	0
f	0
cc	1
nc	1
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;

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 = \FastRoute\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)
    {
        if (!file_exists($swaggerJson)) {
            throw new SchemaNotFoundException("Schema '$swaggerJson' not found");
        }

        $schema = json_decode(file_get_contents($swaggerJson), true);
        if (!isset($schema['paths'])) {
            throw new SchemaInvalidException("Schema '$swaggerJson' is invalid");
        }

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

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

    /**
     * @param $schema
     * @return array
     * @throws OperationIdInvalidException
     */
    protected function generateRoutes($schema)
    {
        $basePath = isset($schema["basePath"]) ? $schema["basePath"] : "";

        $pathList = $this->sortPaths(array_keys($schema['paths']));

        $routes = [];
        foreach ($pathList as $path) {
            foreach ($schema['paths'][$path] as $method => $properties) {
                $handler = $this->getMethodHandler($method, $basePath . $path, $properties);
                if (!isset($properties['operationId'])) {
                    throw new OperationIdInvalidException('OperationId was not found');
                }

                $parts = explode('::', $properties['operationId']);
                if (count($parts) !== 2) {
                    throw new OperationIdInvalidException(
                        'OperationId needs to be in the format Namespace\\class::method'
                    );
                }

                $routes[] = new RoutePattern(
                    strtoupper($method),
                    $basePath . $path,
                    $handler,
                    $parts[1],
                    $parts[0]
                );
            }
        }

        return $routes;
    }

    protected function sortPaths($pathList)
    {
        usort($pathList, function ($left, $right) {
            if (strpos($left, '{') === false && strpos($right, '{') !== false) {

                return -16384;
            }
            if (strpos($left, '{') !== false && strpos($right, '{') === false) {

                return 16384;
            }
            if (strpos($left, $right) !== false) {
                return -16384;
            }
            if (strpos($right, $left) !== false) {
                return 16384;
            }
            return strcmp($left, $right);
        });

        return $pathList;
    }

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

        $produces = $properties['produces'];
        if (is_array($produces)) {
            $produces = $produces[0];
        }

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

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

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

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


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
24		class ServerRequestHandler
25		{
26		const OK = "OK";
27		const METHOD_NOT_ALLOWED = "NOT_ALLOWED";
28		const NOT_FOUND = "NOT FOUND";
29
30		protected $routes = null;
31
32		protected $defaultHandler = null;
33
34		protected $mimeTypeHandler = [
35		"text/xml" => XmlHandler::class,
36		"application/xml" => XmlHandler::class,
37		"text/html" => HtmlHandler::class,
38		"application/json" => JsonHandler::class
39		];
40
41		protected $pathHandler = [
42
43		];
44
45		public function getRoutes()
46		{
47		return $this->routes;
48		}
49
50		/**
51		* @param RoutePattern[] $routes
52		*/
53		public function setRoutes($routes)
54		{
55		foreach ((array)$routes as $route) {
56		$this->addRoute($route);
57		}
58		}
59
60		/**
61		* @param RoutePattern $route
62		*/
63		public function addRoute(RoutePattern $route)
64		{
65		if (is_null($this->routes)) {
66		$this->routes = [];
67		}
68		$this->routes[] = $route;
69		}
70
71		/**
72		* @return HandleOutputInterface
73		*/
74		public function getDefaultHandler()
75		{
76		if (empty($this->defaultHandler)) {
77		$this->defaultHandler = new JsonHandler();
78		}
79		return $this->defaultHandler;
80		}
81
82		/**
83		* @param HandleOutputInterface $defaultHandler
84		*/
85		public function setDefaultHandler(HandleOutputInterface $defaultHandler)
86		{
87		$this->defaultHandler = $defaultHandler;
88		}
89
90		/**
91		* @throws ClassNotFoundException
92		* @throws Error404Exception
93		* @throws Error405Exception
94		* @throws Error520Exception
95		* @throws InvalidClassException
96		*/
97		protected function process()
98		{
99		// Initialize ErrorHandler with default error handler
100		ErrorHandler::getInstance()->register();
101
102		// Get the URL parameters
103		$httpMethod = $_SERVER['REQUEST_METHOD'];
104		$uri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
105		parse_str(parse_url($_SERVER['REQUEST_URI'], PHP_URL_QUERY), $queryStr);
106
107		// Generic Dispatcher for RestServer
108		$dispatcher = \FastRoute\simpleDispatcher(function (RouteCollector $r) {
109
110		foreach ($this->getRoutes() as $route) {
111		$r->addRoute(
112		$route->properties('method'),
113		$route->properties('pattern'),
114		[
115		"handler" => $route->properties('handler'),
116		"class" => $route->properties('class'),
117		"function" => $route->properties('function')
118		]
119		);
120		}
121		});
122
123		$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 `104` 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...
124
125		// Default Handler for errors
126		$this->getDefaultHandler()->writeHeader();
127		ErrorHandler::getInstance()->setHandler($this->getDefaultHandler()->getErrorHandler());
128
129		// Processing
130		switch ($routeInfo[0]) {
131		case Dispatcher::NOT_FOUND:
132		throw new Error404Exception("404 Route '$uri' Not found");
133
134		case Dispatcher::METHOD_NOT_ALLOWED:
135		throw new Error405Exception('405 Method Not Allowed');
136
137		case Dispatcher::FOUND:
138		// ... 200 Process:
139		$vars = array_merge($routeInfo[2], $queryStr);
140
141		// Instantiate the Service Handler
142		$handlerRequest = $routeInfo[1];
143
144		// Execute the request
145		$handler = !empty($handlerRequest['handler']) ? $handlerRequest['handler'] : $this->getDefaultHandler();
146		$this->executeRequest(
147		new $handler(),
148		$handlerRequest['class'],
149		$handlerRequest['function'],
150		$vars
151		);
152
153		break;
154
155		default:
156		throw new Error520Exception('Unknown');
157		}
158		}
159
160		/**
161		* @param HandleOutputInterface $handler
162		* @param string $class
163		* @param string $function
164		* @param array $vars
165		* @throws ClassNotFoundException
166		* @throws InvalidClassException
167		*/
168		protected function executeRequest($handler, $class, $function, $vars)
169		{
170		// Setting Default Headers and Error Handler
171		$handler->writeHeader();
172		ErrorHandler::getInstance()->setHandler($handler->getErrorHandler());
173
174		// Set all default values
175		foreach (array_keys($vars) as $key) {
176		$_REQUEST[$key] = $_GET[$key] = $vars[$key];
177		}
178
179		// Create the Request and Response methods
180		$request = new HttpRequest($_GET, $_POST, $_SERVER, isset($_SESSION) ? $_SESSION : [], $_COOKIE);
181		$response = new HttpResponse();
182
183		// Process Closure
184		if ($function instanceof Closure) {
185		$function($response, $request);
186		echo $handler->processResponse($response);
187		return;
188		}
189
190		// Process Class::Method()
191		if (!class_exists($class)) {
192		throw new ClassNotFoundException("Class '$class' defined in the route is not found");
193		}
194		$instance = new $class();
195		if (!method_exists($instance, $function)) {
196		throw new InvalidClassException("There is no method '$class::$function''");
197		}
198		$instance->$function($response, $request);
199		$handler->processResponse($response);
200		}
201
202		/**
203		* Handle the ROUTE (see web/app-dist.php)
204		*
205		* @param RoutePattern[]\|null $routePattern
206		* @param bool $outputBuffer
207		* @param bool $session
208		* @return bool\|void
209		* @throws ClassNotFoundException
210		* @throws Error404Exception
211		* @throws Error405Exception
212		* @throws Error520Exception
213		* @throws InvalidClassException
214		*/
215		public function handle($routePattern = null, $outputBuffer = true, $session = true)
216		{
217		if ($outputBuffer) {
218		ob_start();
219		}
220		if ($session) {
221		session_start();
222		}
223
224		/**
225		* @var ServerRequestHandler
226		*/
227		$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 215 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...
228
229		// --------------------------------------------------------------------------
230		// Check if script exists or if is itself
231		// --------------------------------------------------------------------------
232
233		$debugBacktrace = debug_backtrace();
234		if (!empty($_SERVER['SCRIPT_FILENAME'])
235		&& file_exists($_SERVER['SCRIPT_FILENAME'])
236		&& basename($_SERVER['SCRIPT_FILENAME']) !== basename($debugBacktrace[0]['file'])
237		) {
238		$file = $_SERVER['SCRIPT_FILENAME'];
239		if (strrchr($file, '.') === ".php") {
240		require_once($file);
241		} else {
242		if (!defined("RESTSERVER_TEST")) {
243		header("Content-Type: " . $this->mimeContentType($file));
244		}
245
246		echo file_get_contents($file);
247		}
248		return true;
249		}
250
251		return $this->process();
252		}
253
254		/**
255		* Get the Mime Type based on the filename
256		*
257		* @param string $filename
258		* @return string
259		* @throws Error404Exception
260		*/
261		public function mimeContentType($filename)
262		{
263
264		$mimeTypes = array(
265		'txt' => 'text/plain',
266		'htm' => 'text/html',
267		'html' => 'text/html',
268		'php' => 'text/html',
269		'css' => 'text/css',
270		'js' => 'application/javascript',
271		'json' => 'application/json',
272		'xml' => 'application/xml',
273		'swf' => 'application/x-shockwave-flash',
274		'flv' => 'video/x-flv',
275		// images
276		'png' => 'image/png',
277		'jpe' => 'image/jpeg',
278		'jpeg' => 'image/jpeg',
279		'jpg' => 'image/jpeg',
280		'gif' => 'image/gif',
281		'bmp' => 'image/bmp',
282		'ico' => 'image/vnd.microsoft.icon',
283		'tiff' => 'image/tiff',
284		'tif' => 'image/tiff',
285		'svg' => 'image/svg+xml',
286		'svgz' => 'image/svg+xml',
287		// archives
288		'zip' => 'application/zip',
289		'rar' => 'application/x-rar-compressed',
290		'exe' => 'application/x-msdownload',
291		'msi' => 'application/x-msdownload',
292		'cab' => 'application/vnd.ms-cab-compressed',
293		// audio/video
294		'mp3' => 'audio/mpeg',
295		'qt' => 'video/quicktime',
296		'mov' => 'video/quicktime',
297		// adobe
298		'pdf' => 'application/pdf',
299		'psd' => 'image/vnd.adobe.photoshop',
300		'ai' => 'application/postscript',
301		'eps' => 'application/postscript',
302		'ps' => 'application/postscript',
303		// ms office
304		'doc' => 'application/msword',
305		'rtf' => 'application/rtf',
306		'xls' => 'application/vnd.ms-excel',
307		'ppt' => 'application/vnd.ms-powerpoint',
308		// open office
309		'odt' => 'application/vnd.oasis.opendocument.text',
310		'ods' => 'application/vnd.oasis.opendocument.spreadsheet',
311		);
312
313		if (!file_exists($filename)) {
314		throw new Error404Exception();
315		}
316
317		$ext = substr(strrchr($filename, "."), 1);
318		if (array_key_exists($ext, $mimeTypes)) {
319		return $mimeTypes[$ext];
320		} elseif (function_exists('finfo_open')) {
321		$finfo = finfo_open(FILEINFO_MIME);
322		$mimetype = finfo_file($finfo, $filename);
323		finfo_close($finfo);
324		return $mimetype;
325		} else {
326		return 'application/octet-stream';
327		}
328		}
329
330		/**
331		* @param $swaggerJson
332		* @param CacheInterface\|null $cache
333		* @throws SchemaInvalidException
334		* @throws SchemaNotFoundException
335		* @throws OperationIdInvalidException
336		* @throws InvalidArgumentException
337		*/
338		public function setRoutesSwagger($swaggerJson, CacheInterface $cache = null)
339		{
340		if (!file_exists($swaggerJson)) {
341		throw new SchemaNotFoundException("Schema '$swaggerJson' not found");
342		}
343
344		$schema = json_decode(file_get_contents($swaggerJson), true);
345		if (!isset($schema['paths'])) {
346		throw new SchemaInvalidException("Schema '$swaggerJson' is invalid");
347		}
348
349		if (is_null($cache)) {
350		$cache = new NoCacheEngine();
351		}
352
353		$routePattern = $cache->get('SERVERHANDLERROUTES', false);
354		if ($routePattern === false) {
355		$routePattern = $this->generateRoutes($schema);
356		$cache->set('SERVERHANDLERROUTES', $routePattern);
357		}
358		$this->setRoutes($routePattern);
359		}
360
361		/**
362		* @param $schema
363		* @return array
364		* @throws OperationIdInvalidException
365		*/
366		protected function generateRoutes($schema)
367		{
368		$basePath = isset($schema["basePath"]) ? $schema["basePath"] : "";
369
370		$pathList = $this->sortPaths(array_keys($schema['paths']));
371
372		$routes = [];
373		foreach ($pathList as $path) {
374		foreach ($schema['paths'][$path] as $method => $properties) {
375		$handler = $this->getMethodHandler($method, $basePath . $path, $properties);
376		if (!isset($properties['operationId'])) {
377		throw new OperationIdInvalidException('OperationId was not found');
378		}
379
380		$parts = explode('::', $properties['operationId']);
381		if (count($parts) !== 2) {
382		throw new OperationIdInvalidException(
383		'OperationId needs to be in the format Namespace\\class::method'
384		);
385		}
386
387		$routes[] = new RoutePattern(
388		strtoupper($method),
389		$basePath . $path,
390		$handler,
391		$parts[1],
392		$parts[0]
393		);
394		}
395		}
396
397		return $routes;
398		}
399
400		protected function sortPaths($pathList)
401		{
402		usort($pathList, function ($left, $right) {
403	View Code Duplication	if (strpos($left, '{') === false && strpos($right, '{') !== false) {
		0 ignored issues – show Duplication introduced 2018-01-30 14:24 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
404		return -16384;
405		}
406	View Code Duplication	if (strpos($left, '{') !== false && strpos($right, '{') === false) {
		0 ignored issues – show Duplication introduced 2018-01-30 14:24 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
407		return 16384;
408		}
409		if (strpos($left, $right) !== false) {
410		return -16384;
411		}
412		if (strpos($right, $left) !== false) {
413		return 16384;
414		}
415		return strcmp($left, $right);
416		});
417
418		return $pathList;
419		}
420
421		/**
422		* @param $method
423		* @param $path
424		* @param $properties
425		* @return string
426		* @throws OperationIdInvalidException
427		*/
428		protected function getMethodHandler($method, $path, $properties)
429		{
430		$method = strtoupper($method);
431		if (isset($this->pathHandler["$method::$path"])) {
432		return $this->pathHandler["$method::$path"];
433		}
434		if (!isset($properties['produces'])) {
435		return get_class($this->getDefaultHandler());
436		}
437
438		$produces = $properties['produces'];
439		if (is_array($produces)) {
440		$produces = $produces[0];
441		}
442
443		if (!isset($this->mimeTypeHandler[$produces])) {
444		throw new OperationIdInvalidException("There is no handler for $produces");
445		}
446
447		return $this->mimeTypeHandler[$produces];
448		}
449
450		public function setMimeTypeHandler($mimetype, $handler)
451		{
452		$this->mimeTypeHandler[$mimetype] = $handler;
453		}
454
455		public function setPathHandler($method, $path, $handler)
456		{
457		$method = strtoupper($method);
458		$this->pathHandler["$method::$path"] = $handler;
459		}
460		}
461

byjg / restserver

Push — master ( 382c30...1fdbd5 )

ServerRequestHandler::setPathHandler() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like