ResponseCalls::callDingoRoute() - Code Metrics - Inspection of "First implementation of plugin architecture" - mpociot/laravel-apidoc-generator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#570)

by Marcel

created 2019-09-07 14:44 UTC

ResponseCalls::callDingoRoute() A

↳ Parent: ResponseCalls

Complexity

Conditions	4
Paths	8

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	29
rs	9.456
c	0
b	0
f	0
cc	4
nc	8
nop	1

<?php

namespace Mpociot\ApiDoc\Strategies\Responses;

use Dingo\Api\Dispatcher;
use Illuminate\Support\Str;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Routing\Route;
use Mpociot\ApiDoc\Tools\Flags;
use Mpociot\ApiDoc\Tools\Utils;
use Mpociot\ApiDoc\Strategies\Strategy;
use Mpociot\ApiDoc\Tools\Traits\ParamHelpers;

/**
 * Make a call to the route and retrieve its response.
 */
class ResponseCalls extends Strategy
{
    use ParamHelpers;

    /**
     * @param Route $route
     * @param \ReflectionClass $controller
     * @param \ReflectionMethod $method
     * @param array $routeRules
     * @param array $context
     *
     * @return array|null
     */
    public function __invoke(Route $route, \ReflectionClass $controller, \ReflectionMethod $method, array $routeRules, array $context = [])
    {
        $rulesToApply = $routeRules['response_calls'] ?? [];
        if (! $this->shouldMakeApiCall($route, $rulesToApply, $context)) {
            return null;
        }

        $this->configureEnvironment($rulesToApply);

        // Mix in parsed parameters with manually specified parameters.
        $bodyParameters = array_merge($context['cleanBodyParameters'], $rulesToApply['body'] ?? []);
        $queryParameters = array_merge($context['cleanQueryParameters'], $rulesToApply['query'] ?? []);
        $request = $this->prepareRequest($route, $rulesToApply, $bodyParameters, $queryParameters);

        try {
            $response = [200 => $this->makeApiCall($request)->getContent()];
        } catch (\Exception $e) {
            echo 'Exception thrown during response call for ['.implode(',', $route->methods)."] {$route->uri}.\n";
            if (Flags::$shouldBeVerbose) {
                Utils::dumpException($e);
            } else {
                echo "Run this again with the --verbose flag to see the exception.\n";
            }
            $response = null;
        } finally {
            $this->finish();
        }

        return $response;
    }

    /**
     * @param array $rulesToApply
     *
     * @return void
     */
    private function configureEnvironment(array $rulesToApply)
    {
        $this->startDbTransaction();
        $this->setEnvironmentVariables($rulesToApply['env'] ?? []);

        $this->setLaravelConfigs($rulesToApply['config'] ?? []);
    }

    /**
     * @param Route $route
     * @param array $rulesToApply
     * @param array $bodyParams
     * @param array $queryParams
     *
     * @return Request
     */
    protected function prepareRequest(Route $route, array $rulesToApply, array $bodyParams, array $queryParams)
    {
        $uri = Utils::getFullUrl($route, $rulesToApply['bindings'] ?? []);
        $routeMethods = $this->getMethods($route);
        $method = array_shift($routeMethods);
        $cookies = isset($rulesToApply['cookies']) ? $rulesToApply['cookies'] : [];
        $request = Request::create($uri, $method, [], $cookies, [], $this->transformHeadersToServerVars($rulesToApply['headers'] ?? []));
        $request = $this->addHeaders($request, $route, $rulesToApply['headers'] ?? []);

        $request = $this->addQueryParameters($request, $queryParams);
        $request = $this->addBodyParameters($request, $bodyParams);

        return $request;
    }

    /**
     * @param array $env
     *
     * @return void
     *
     * @deprecated in favour of Laravel config variables
     */
    private function setEnvironmentVariables(array $env)
    {
        foreach ($env as $name => $value) {
            putenv("$name=$value");

            $_ENV[$name] = $value;
            $_SERVER[$name] = $value;
        }
    }

    /**
     * @param array $config
     *
     * @return void
     */
    private function setLaravelConfigs(array $config)
    {
        if (empty($config)) {
            return;
        }

        foreach ($config as $name => $value) {
            config([$name => $value]);
        }
    }

    /**
     * @return void
     */
    private function startDbTransaction()
    {
        try {
            app('db')->beginTransaction();
        } catch (\Exception $e) {

        }
    }

    /**
     * @return void
     */
    private function endDbTransaction()
    {
        try {
            app('db')->rollBack();
        } catch (\Exception $e) {

        }
    }

    /**
     * @return void
     */
    private function finish()
    {
        $this->endDbTransaction();
    }

    /**
     * @param Request $request
     *
     * @return \Illuminate\Http\JsonResponse|mixed
     */
    public function callDingoRoute(Request $request)
    {
        /** @var Dispatcher $dispatcher */
        $dispatcher = app(\Dingo\Api\Dispatcher::class);

        foreach ($request->headers as $header => $value) {
            $dispatcher->header($header, $value);
        }

        // set domain and body parameters
        $dispatcher->on($request->header('SERVER_NAME'))
            ->with($request->request->all());

        // set URL and query parameters
        $uri = $request->getRequestUri();
        $query = $request->getQueryString();
        if (! empty($query)) {
            $uri .= "?$query";
        }
        $response = call_user_func_array([$dispatcher, strtolower($request->method())], [$uri]);

        // the response from the Dingo dispatcher is the 'raw' response from the controller,
        // so we have to ensure it's JSON first
        if (! $response instanceof Response) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
            $response = response()->json($response);
        }

        return $response;
    }

    /**
     * @param Route $route
     *
     * @return array
     */
    public function getMethods(Route $route)
    {
        return array_diff($route->methods(), ['HEAD']);
    }

    /**
     * @param Request $request
     * @param Route $route
     * @param array|null $headers
     *
     * @return Request
     */
    private function addHeaders(Request $request, Route $route, $headers)
    {
        // set the proper domain
        if ($route->getDomain()) {
            $request->headers->add([
                'HOST' => $route->getDomain(),
            ]);
            $request->server->add([
                'HTTP_HOST' => $route->getDomain(),
                'SERVER_NAME' => $route->getDomain(),
            ]);
        }

        $headers = collect($headers);

        if (($headers->get('Accept') ?: $headers->get('accept')) === 'application/json') {
            $request->setRequestFormat('json');
        }

        return $request;
    }

    /**
     * @param Request $request
     * @param array $query
     *
     * @return Request
     */
    private function addQueryParameters(Request $request, array $query)
    {
        $request->query->add($query);
        $request->server->add(['QUERY_STRING' => http_build_query($query)]);

        return $request;
    }

    /**
     * @param Request $request
     * @param array $body
     *
     * @return Request
     */
    private function addBodyParameters(Request $request, array $body)
    {
        $request->request->add($body);

        return $request;
    }

    /**
     * @param Request $request
     *
     * @throws \Exception
     *
     * @return \Illuminate\Http\JsonResponse|mixed|\Symfony\Component\HttpFoundation\Response
     */
    protected function makeApiCall(Request $request)
    {
        if (config('apidoc.router') == 'dingo') {
            $response = $this->callDingoRoute($request);
        } else {
            $response = $this->callLaravelRoute($request);
        }

        return $response;
    }

    /**
     * @param Request $request
     *
     * @throws \Exception
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    protected function callLaravelRoute(Request $request): \Symfony\Component\HttpFoundation\Response
    {
        $kernel = app(\Illuminate\Contracts\Http\Kernel::class);
        $response = $kernel->handle($request);
        $kernel->terminate($request, $response);

        return $response;
    }

    /**
     * @param Route $route
     * @param array $rulesToApply
     *
     * @return bool
     */
    private function shouldMakeApiCall(Route $route, array $rulesToApply, array $context): bool
    {
        $allowedMethods = $rulesToApply['methods'] ?? [];
        if (empty($allowedMethods)) {
            return false;
        }

        if (! empty($context['responses'])) {
            // Don't attempt a response call if there are already responses
            return false;
        }

        if (is_string($allowedMethods) && $allowedMethods == '*') {
            return true;
        }

        if (array_search('*', $allowedMethods) !== false) {
            return true;
        }

        $routeMethods = $this->getMethods($route);
        if (in_array(array_shift($routeMethods), $allowedMethods)) {
            return true;
        }

        return false;
    }

    /**
     * Transform headers array to array of $_SERVER vars with HTTP_* format.
     *
     * @param  array  $headers
     *
     * @return array
     */
    protected function transformHeadersToServerVars(array $headers)
    {
        $server = [];
        $prefix = 'HTTP_';
        foreach ($headers as $name => $value) {
            $name = strtr(strtoupper($name), '-', '_');
            if (! Str::startsWith($name, $prefix) && $name !== 'CONTENT_TYPE') {
                $name = $prefix.$name;
            }
            $server[$name] = $value;
        }

        return $server;
    }
}


Pull Request — master (#570)

ResponseCalls::callDingoRoute() A

Complexity

Size

Duplication

Importance

1. Missing dependencies

2. Missing use statement

1			<?php
2
3			namespace Mpociot\ApiDoc\Strategies\Responses;
4
5			use Dingo\Api\Dispatcher;
6			use Illuminate\Support\Str;
7			use Illuminate\Http\Request;
8			use Illuminate\Http\Response;
9			use Illuminate\Routing\Route;
10			use Mpociot\ApiDoc\Tools\Flags;
11			use Mpociot\ApiDoc\Tools\Utils;
12			use Mpociot\ApiDoc\Strategies\Strategy;
13			use Mpociot\ApiDoc\Tools\Traits\ParamHelpers;
14
15			/**
16			* Make a call to the route and retrieve its response.
17			*/
18			class ResponseCalls extends Strategy
19			{
20			use ParamHelpers;
21
22			/**
23			* @param Route $route
24			* @param \ReflectionClass $controller
25			* @param \ReflectionMethod $method
26			* @param array $routeRules
27			* @param array $context
28			*
29			* @return array\|null
30			*/
31			public function __invoke(Route $route, \ReflectionClass $controller, \ReflectionMethod $method, array $routeRules, array $context = [])
32			{
33			$rulesToApply = $routeRules['response_calls'] ?? [];
34			if (! $this->shouldMakeApiCall($route, $rulesToApply, $context)) {
35			return null;
36			}
37
38			$this->configureEnvironment($rulesToApply);
39
40			// Mix in parsed parameters with manually specified parameters.
41			$bodyParameters = array_merge($context['cleanBodyParameters'], $rulesToApply['body'] ?? []);
42			$queryParameters = array_merge($context['cleanQueryParameters'], $rulesToApply['query'] ?? []);
43			$request = $this->prepareRequest($route, $rulesToApply, $bodyParameters, $queryParameters);
44
45			try {
46			$response = [200 => $this->makeApiCall($request)->getContent()];
47			} catch (\Exception $e) {
48			echo 'Exception thrown during response call for ['.implode(',', $route->methods)."] {$route->uri}.\n";
49			if (Flags::$shouldBeVerbose) {
50			Utils::dumpException($e);
51			} else {
52			echo "Run this again with the --verbose flag to see the exception.\n";
53			}
54			$response = null;
55			} finally {
56			$this->finish();
57			}
58
59			return $response;
60			}
61
62			/**
63			* @param array $rulesToApply
64			*
65			* @return void
66			*/
67			private function configureEnvironment(array $rulesToApply)
68			{
69			$this->startDbTransaction();
70			$this->setEnvironmentVariables($rulesToApply['env'] ?? []);
			0 ignored issues – show Deprecated Code introduced 2019-09-02 20:57 UTC by Report Bug Copy Issue Report The method `Mpociot\ApiDoc\Strategie...tEnvironmentVariables()` has been deprecated with message: in favour of Laravel config variables This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
71			$this->setLaravelConfigs($rulesToApply['config'] ?? []);
72			}
73
74			/**
75			* @param Route $route
76			* @param array $rulesToApply
77			* @param array $bodyParams
78			* @param array $queryParams
79			*
80			* @return Request
81			*/
82			protected function prepareRequest(Route $route, array $rulesToApply, array $bodyParams, array $queryParams)
83			{
84			$uri = Utils::getFullUrl($route, $rulesToApply['bindings'] ?? []);
85			$routeMethods = $this->getMethods($route);
86			$method = array_shift($routeMethods);
87			$cookies = isset($rulesToApply['cookies']) ? $rulesToApply['cookies'] : [];
88			$request = Request::create($uri, $method, [], $cookies, [], $this->transformHeadersToServerVars($rulesToApply['headers'] ?? []));
89			$request = $this->addHeaders($request, $route, $rulesToApply['headers'] ?? []);
90
91			$request = $this->addQueryParameters($request, $queryParams);
92			$request = $this->addBodyParameters($request, $bodyParams);
93
94			return $request;
95			}
96
97			/**
98			* @param array $env
99			*
100			* @return void
101			*
102			* @deprecated in favour of Laravel config variables
103			*/
104			private function setEnvironmentVariables(array $env)
105			{
106			foreach ($env as $name => $value) {
107			putenv("$name=$value");
108
109			$_ENV[$name] = $value;
110			$_SERVER[$name] = $value;
111			}
112			}
113
114			/**
115			* @param array $config
116			*
117			* @return void
118			*/
119			private function setLaravelConfigs(array $config)
120			{
121			if (empty($config)) {
122			return;
123			}
124
125			foreach ($config as $name => $value) {
126			config([$name => $value]);
127			}
128			}
129
130			/**
131			* @return void
132			*/
133			private function startDbTransaction()
134			{
135			try {
136			app('db')->beginTransaction();
137			} catch (\Exception $e) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2018-12-03 08:55 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
138			}
139			}
140
141			/**
142			* @return void
143			*/
144			private function endDbTransaction()
145			{
146			try {
147			app('db')->rollBack();
148			} catch (\Exception $e) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2018-10-16 00:55 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
149			}
150			}
151
152			/**
153			* @return void
154			*/
155			private function finish()
156			{
157			$this->endDbTransaction();
158			}
159
160			/**
161			* @param Request $request
162			*
163			* @return \Illuminate\Http\JsonResponse\|mixed
164			*/
165			public function callDingoRoute(Request $request)
166			{
167			/** @var Dispatcher $dispatcher */
168			$dispatcher = app(\Dingo\Api\Dispatcher::class);
169
170			foreach ($request->headers as $header => $value) {
171			$dispatcher->header($header, $value);
172			}
173
174			// set domain and body parameters
175			$dispatcher->on($request->header('SERVER_NAME'))
176			->with($request->request->all());
177
178			// set URL and query parameters
179			$uri = $request->getRequestUri();
180			$query = $request->getQueryString();
181			if (! empty($query)) {
182			$uri .= "?$query";
183			}
184			$response = call_user_func_array([$dispatcher, strtolower($request->method())], [$uri]);
185
186			// the response from the Dingo dispatcher is the 'raw' response from the controller,
187			// so we have to ensure it's JSON first
188			if (! $response instanceof Response) {
			0 ignored issues – show Bug introduced 2019-08-25 21:49 UTC by Report Bug Copy Issue Report The class `Illuminate\Http\Response` does not exist. Did you forget a USE statement, or did you not list all dependencies? This error could be the result of: 1. Missing dependencies PHP Analyzer uses your `composer.json` file (if available) to determine the dependencies of your project and to determine all the available classes and functions. It expects the `composer.json` to be in the root folder of your repository. Are you sure this class is defined by one of your dependencies, or did you maybe not list a dependency in either the `require` or `require-dev` section? 2. Missing use statement PHP does not complain about undefined classes in `ìnstanceof` checks. For example, the following PHP code will work perfectly fine: if ($x instanceof DoesNotExist) { // Do something. } If you have not tested against this specific condition, such errors might go unnoticed. Loading history...
189			$response = response()->json($response);
190			}
191
192			return $response;
193			}
194
195			/**
196			* @param Route $route
197			*
198			* @return array
199			*/
200			public function getMethods(Route $route)
201			{
202			return array_diff($route->methods(), ['HEAD']);
203			}
204
205			/**
206			* @param Request $request
207			* @param Route $route
208			* @param array\|null $headers
209			*
210			* @return Request
211			*/
212			private function addHeaders(Request $request, Route $route, $headers)
213			{
214			// set the proper domain
215			if ($route->getDomain()) {
216			$request->headers->add([
217			'HOST' => $route->getDomain(),
218			]);
219			$request->server->add([
220			'HTTP_HOST' => $route->getDomain(),
221			'SERVER_NAME' => $route->getDomain(),
222			]);
223			}
224
225			$headers = collect($headers);
226
227			if (($headers->get('Accept') ?: $headers->get('accept')) === 'application/json') {
228			$request->setRequestFormat('json');
229			}
230
231			return $request;
232			}
233
234			/**
235			* @param Request $request
236			* @param array $query
237			*
238			* @return Request
239			*/
240			private function addQueryParameters(Request $request, array $query)
241			{
242			$request->query->add($query);
243			$request->server->add(['QUERY_STRING' => http_build_query($query)]);
244
245			return $request;
246			}
247
248			/**
249			* @param Request $request
250			* @param array $body
251			*
252			* @return Request
253			*/
254			private function addBodyParameters(Request $request, array $body)
255			{
256			$request->request->add($body);
257
258			return $request;
259			}
260
261			/**
262			* @param Request $request
263			*
264			* @throws \Exception
265			*
266			* @return \Illuminate\Http\JsonResponse\|mixed\|\Symfony\Component\HttpFoundation\Response
267			*/
268			protected function makeApiCall(Request $request)
269			{
270			if (config('apidoc.router') == 'dingo') {
271			$response = $this->callDingoRoute($request);
272			} else {
273			$response = $this->callLaravelRoute($request);
274			}
275
276			return $response;
277			}
278
279			/**
280			* @param Request $request
281			*
282			* @throws \Exception
283			*
284			* @return \Symfony\Component\HttpFoundation\Response
285			*/
286			protected function callLaravelRoute(Request $request): \Symfony\Component\HttpFoundation\Response
287			{
288			$kernel = app(\Illuminate\Contracts\Http\Kernel::class);
289			$response = $kernel->handle($request);
290			$kernel->terminate($request, $response);
291
292			return $response;
293			}
294
295			/**
296			* @param Route $route
297			* @param array $rulesToApply
298			*
299			* @return bool
300			*/
301			private function shouldMakeApiCall(Route $route, array $rulesToApply, array $context): bool
302			{
303			$allowedMethods = $rulesToApply['methods'] ?? [];
304			if (empty($allowedMethods)) {
305			return false;
306			}
307
308			if (! empty($context['responses'])) {
309			// Don't attempt a response call if there are already responses
310			return false;
311			}
312
313			if (is_string($allowedMethods) && $allowedMethods == '*') {
314			return true;
315			}
316
317			if (array_search('*', $allowedMethods) !== false) {
318			return true;
319			}
320
321			$routeMethods = $this->getMethods($route);
322			if (in_array(array_shift($routeMethods), $allowedMethods)) {
323			return true;
324			}
325
326			return false;
327			}
328
329			/**
330			* Transform headers array to array of $_SERVER vars with HTTP_* format.
331			*
332			* @param array $headers
333			*
334			* @return array
335			*/
336			protected function transformHeadersToServerVars(array $headers)
337			{
338			$server = [];
339			$prefix = 'HTTP_';
340			foreach ($headers as $name => $value) {
341			$name = strtr(strtoupper($name), '-', '_');
342			if (! Str::startsWith($name, $prefix) && $name !== 'CONTENT_TYPE') {
343			$name = $prefix.$name;
344			}
345			$server[$name] = $value;
346			}
347
348			return $server;
349			}
350			}
351

mpociot / laravel-apidoc-generator

Pull Request — master (#570)

ResponseCalls::callDingoRoute() A

Complexity

Size

Duplication

Importance

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like