Builder::commandToRequestTransformer() - Code Metrics - Inspection of "Fix error handling." - indragunawan/rest-service - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b8a64c...327515 )

by Indra

created 2016-08-29 08:23 UTC

Builder::commandToRequestTransformer() C

↳ Parent: Builder

Complexity

Conditions	10
Paths	1

Size

Total Lines	60
Code Lines	36

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	110

Importance

Changes	3
Bugs	0	Features	1

Metric	Value
c	3
b	0
f	1
dl	0
loc	60
ccs	0
cts	47
cp	0
rs	6.5333
cc	10
eloc	36
nc	1
nop	0
crap	110

How to fix Long Method Complexity

<?php

namespace IndraGunawan\RestService;

use GuzzleHttp;
use GuzzleHttp\Command\CommandInterface;
use GuzzleHttp\Exception\BadResponseException as GuzzleBadResponseException;
use GuzzleHttp\Psr7\Request;
use IndraGunawan\RestService\Exception\BadRequestException;
use IndraGunawan\RestService\Exception\BadResponseException;
use IndraGunawan\RestService\Exception\CommandException;
use IndraGunawan\RestService\Exception\ValidatorException;
use IndraGunawan\RestService\Validator\Validator;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

class Builder
{
    /**
     * @var ServiceInterface
     */
    private $service;

    /**
     * @var ValueFormatter
     */
    private $formatter;

    /**
     * @param ServiceInterface $service
     */
    public function __construct(ServiceInterface $service)
    {
        $this->service = $service;
        $this->formatter = new ValueFormatter();
    }

    /**
     * Transform command to request.
     *
     * @return \Closure
     */
    public function commandToRequestTransformer()
    {
        return function (CommandInterface $command) {
            if (!$this->service->hasOperation($command->getName())) {
                throw new CommandException(
                    sprintf(
                        'Command "%s" not found',
                        $command->getName()
                    ),
                    $command
                );
            }

            $operation = $this->service->getOperation($command->getName());

            $result = $this->transformData($command, $command->toArray(), $operation ?: [], 'request');

            $uri = ltrim($operation['requestUri'], '/');
            if ($result['uri']) {
                // replace uri
                $patterns = [];
                $replacements = [];
                foreach ($result['uri'] as $key => $value) {
                    $patterns[] = '/{'.$key.'}/';
                    $replacements[] = $value;
                }

                $uri = preg_replace($patterns, $replacements, $uri);
            }

            $body = null;
            if ('rest_json' === $operation['requestProtocol']) {
                $body = GuzzleHttp\json_encode($result['body']);
                $result['header']['Content-Type'] = 'application/json';
            } elseif ('form_params' === $operation['requestProtocol']) {
                $body = http_build_query($result['body'], '', '&');
                $result['header']['Content-Type'] = 'application/x-www-form-urlencoded';
            }

            if ($result['query']) {
                $uri .= sprintf('?%s', http_build_query($result['query'], null, '&', PHP_QUERY_RFC3986));
            }

            // GET method has no body, concat to uri
            if (in_array($operation['httpMethod'], ['GET'])) {
                // if uri has no query string, append '?' else '&'
                $uri .= (false === strpos($uri, '?')) ? '?' : '&';

                $uri .= http_build_query($result['body'], null, '&', PHP_QUERY_RFC3986);
                $result['body'] = null;
            }

            return new Request(
                $operation['httpMethod'],
                $this->service->getEndpoint().$uri,
                $result['header'],
                $body
            );
        };
    }

    /**
     * Transform response to result.
     *
     * @return \Closure
     */
    public function responseToResultTransformer()
    {
        return function (
            ResponseInterface $response,
            RequestInterface $request,
            CommandInterface $command
        ) {
            $operation = $this->service->getOperation($command->getName());
            $this->processResponseError($operation ?: [], $request, $response);

            $body = [];
            if ('rest_json' === $operation['responseProtocol']) {
                $body = GuzzleHttp\json_decode($response->getBody(), true);
            }

            $result = $this->transformData($command, $body, $operation, 'response');

            foreach ($response->getHeaders() as $name => $header) {
                $result['header'][$name] = is_array($header) ? array_pop($header) : null;
            }

            return new Result($result['body'], $result['header']);
        };
    }

    public function badResponseExceptionParser()
    {
        return function (CommandInterface $command, GuzzleBadResponseException $e) {
            $operation = $this->service->getOperation($command->getName());

            $this->processResponseError(
                $operation ?: [],
                $e->getRequest(),
                $e->getResponse(),
                $e
            );
        };
    }

    /**
     * Process response to check is error or not.
     *
     * @param array                           $operation
     * @param RequestInterface                $request
     * @param ResponseInterface               $response
     * @param GuzzleBadResponseException|null $e
     *
     * @throws \IndraGunawan\RestService\Exception\BadResponseException|null
     */
    private function processResponseError(
        array $operation,
        RequestInterface $request,
        ResponseInterface $response = null,
        GuzzleBadResponseException $e = null
    ) {
        $body = null;
        if ('rest_json' === $operation['responseProtocol']) {
            try {
                $body = GuzzleHttp\json_decode((!is_null($response)) ? $response->getBody() : '', true);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            } catch (\InvalidArgumentException $ex) {
                throw new BadResponseException(
                    '',
                    $ex->getMessage(),
                    ($e ? $e->getMessage() : ''),
                    $request,
                    $response,
                    $e ? $e->getPrevious() : null
                );
            }
        }

        if ($body) {
            foreach ($operation['errors'] as $name => $error) {
                if ('field' === $error['type']) {
                    $responseCode = $this->parseError($body, $error['codeField']);

                    if (!$responseCode) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                        continue;
                    }

                    // if no ifCode property then return exception
                    if (!$error['ifCode']) {
                        $responseMessage = $this->getErrorMessage($body, $error, $response);

                        throw new BadResponseException(
                            $responseCode,
                            $responseMessage,
                            ($e ? $e->getMessage() : '').' code: '.$responseCode.', message: '.$responseMessage,
                            $request,
                            $response,
                            $e ? $e->getPrevious() : null
                        );
                    }
                } else {
                    $responseCode = $response->getStatusCode();
function someFunction(A $objectMaybe = null)
{
    if ($objectMaybe instanceof A) {
        $objectMaybe->doSomething();
    }
}
                }

                if ($this->checkResponseCode($responseCode, $error['operator'], $error['ifCode'])) {
                    $responseMessage = $this->getErrorMessage($body, $error, $response);

                    throw new BadResponseException(
                        $responseCode,
                        $responseMessage,
                        ($e ? $e->getMessage() : '').'. code: '.$responseCode.', message: '.$responseMessage,
                        $request,
                        $response,
                        $e ? $e->getPrevious() : null
                    );
                }
            }
        }
    }

    /**
     * Parse error codeField from body.
     *
     * @param array  $body
     * @param string $path
     *
     * @return string|null
     */
    private function parseError(array $body, $path)
    {
        $tmp = $body;
        foreach (explode('.', $path) as $key) {
            if (!isset($tmp[$key])) {
                return;
            }

            $tmp = $tmp[$key];
        }

        return $tmp;
    }

    /**
     * Get error message from posible field.
     *
     * @param array                  $body
     * @param array                  $error
     * @param ResponseInterface|null $response
     *
     * @return string
     */
    private function getErrorMessage(array $body, array $error, ResponseInterface $response = null)
    {
        $message = $this->parseError($body, $error['messageField']);
        if (!$message) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $message = $error['defaultMessage'];
        }
        if (!$message) {
            $message = $response->getReasonPhrase();
function someFunction(A $objectMaybe = null)
{
    if ($objectMaybe instanceof A) {
        $objectMaybe->doSomething();
    }
}
        }

        return $message;
    }

    /**
     * Transform and match data with shape.
     *
     * @param CommandInterface $command
     * @param array            $datas
     * @param array            $operation
     * @param string           $action
     *
     * @return array
     */
    private function transformData(CommandInterface $command, array $datas, array $operation, $action)
    {
        $result = [
            'header' => [],
            'uri' => [],
            'query' => [],
            'body' => [],
        ];

        $validator = new Validator();

        if (isset($operation[$action])) {
            $shape = $operation[$action];
        } else {
            $shape = [
                'type' => null,
                'members' => [],
            ];
        }

        $result['body'] = $this->createData(
            $validator,
            $datas,
            $shape,
            $command->getName(),
            $action,
            $result,
            ('request' === $action) ? $operation['strictRequest'] : $operation['strictResponse'],
            $operation['sentEmptyField']
        );

        if (!$validator->validate([$command->getName() => $datas])) {
            // validation failed
            throw $validator->createValidatorException();
        }

        return $result;
    }

    /**
     * Create request/response data and add validation rule.
     *
     * @param Validator $validator
     * @param array     $datas
     * @param array     $shape
     * @param string    $path
     * @param string    $action
     * @param array     &$result
     * @param bool      $isStrict
     * @param bool      $isSentEmptyField
     *
     * @return array
     */
    private function createData(
        Validator $validator,
        array &$datas,
        array $shape,
        $path,
        $action,
        array &$result,
        $isStrict = false,
        $isSentEmptyField = true
    ) {
        $tmpData = $datas;
        $bodyResult = [];
        if ('list' === $shape['type']) {
            $path .= '[*]';
        }

        foreach ($shape['members'] as $name => $parameter) {
            $tmpPath = $path.'['.$name.']';
            $value = isset($datas[$name]) ? $datas[$name] : null;
            if (!$value) {
                $datas[$name] = $parameter['defaultValue'];
            }

            // set validator
            $validator->add($tmpPath, $parameter, $value);

            // if nested children
            if (isset($parameter['members']) && count($parameter['members']) > 0) {
                if (!is_null($value) && !is_array($value)) {
                    throw new ValidatorException($tmpPath, sprintf(
                        'Expected "%s", but got "%s"',
                        $parameter['type'],
                        gettype($value)
                    ));
                }
                if ('list' === $parameter['type']) {
                    $children = $value ?: [];
                    foreach ($children as $idx => $child) {
                        if (!is_array($child)) {
                            throw new ValidatorException($tmpPath, 'Expected "list", but got "map"');
                        }

                        $bodyResult[$parameter['locationName']][] = $this->createData(
                            $validator,
                            $datas[$name][$idx],
                            $parameter,
                            $tmpPath,
                            $action,
                            $result,
                            $isStrict,
                            $isSentEmptyField
                        );
                    }
                } elseif ('map' === $parameter['type']) {
                    if (is_null($value)) {
                        if (array_key_exists($name, $datas)) {
                            unset($tmpData[$name]);
                        }
                        continue;
                    }
                    $children = $value ?: [];
                    foreach (array_keys($parameter['members']) as $key) {
                        if (!array_key_exists($key, $children)) {
                            $children[$key] = null;
                            $datas[$name][$key] = null;
                        }
                    }

                    $bodyResult[$parameter['locationName']] = $this->createData(
                        $validator,
                        $datas[$name],
                        $parameter,
                        $tmpPath,
                        $action,
                        $result,
                        $isStrict,
                        $isSentEmptyField
                    );
                }
            }

            $formattedValue = $this->formatter->format($parameter['type'], $parameter['format'], $value, $parameter['defaultValue']);
            if ('body' !== $parameter['location']) {
                $result[$parameter['location']][$parameter['locationName']] = $formattedValue;
            } else {
                if (!array_key_exists($parameter['locationName'], $bodyResult)) {
                    if (!$value && !is_numeric($value)) {
                        $value = $parameter['defaultValue'];
                    }
                    if ($isSentEmptyField || ($value || is_numeric($value))) {
                        $bodyResult[$parameter['locationName']] = $formattedValue;
                    }
                }
            }
            unset($tmpData[$name]);
        }

        if (count($tmpData) > 0) {
            if ($isStrict) {
                throw new BadRequestException(ucwords($action), 'Undefined parameters "'.implode('", "', array_keys($tmpData)).'"');
            }
            foreach ($tmpData as $name => $child) {
                $bodyResult[$name] = $child;
            }
        }

        return $bodyResult;
    }

    /**
     * Check is responsecode is match with code.
     *
     * @param string $responseCode
     * @param string $operator
     * @param string $code
     *
     * @return bool
     */
    public function checkResponseCode($responseCode, $operator, $code)
    {
        switch ($operator) {
            case '===':
                return $responseCode === $code;
            case '!==':
                return $responseCode !== $code;
            case '!=':
                return $responseCode != $code;
            case '<':
                return $responseCode < $code;
            case '<=':
                return $responseCode <= $code;
            case '>=':
                return $responseCode >= $code;
            case '>':
                return $responseCode > $code;
            default:
                return $responseCode == $code;
        }
    }
}


1			<?php
2
3			namespace IndraGunawan\RestService;
4
5			use GuzzleHttp;
6			use GuzzleHttp\Command\CommandInterface;
7			use GuzzleHttp\Exception\BadResponseException as GuzzleBadResponseException;
8			use GuzzleHttp\Psr7\Request;
9			use IndraGunawan\RestService\Exception\BadRequestException;
10			use IndraGunawan\RestService\Exception\BadResponseException;
11			use IndraGunawan\RestService\Exception\CommandException;
12			use IndraGunawan\RestService\Exception\ValidatorException;
13			use IndraGunawan\RestService\Validator\Validator;
14			use Psr\Http\Message\RequestInterface;
15			use Psr\Http\Message\ResponseInterface;
16
17			class Builder
18			{
19			/**
20			* @var ServiceInterface
21			*/
22			private $service;
23
24			/**
25			* @var ValueFormatter
26			*/
27			private $formatter;
28
29			/**
30			* @param ServiceInterface $service
31			*/
32			public function __construct(ServiceInterface $service)
33			{
34			$this->service = $service;
35			$this->formatter = new ValueFormatter();
36			}
37
38			/**
39			* Transform command to request.
40			*
41			* @return \Closure
42			*/
43			public function commandToRequestTransformer()
44			{
45			return function (CommandInterface $command) {
46			if (!$this->service->hasOperation($command->getName())) {
47			throw new CommandException(
48			sprintf(
49			'Command "%s" not found',
50			$command->getName()
51			),
52			$command
53			);
54			}
55
56			$operation = $this->service->getOperation($command->getName());
57
58			$result = $this->transformData($command, $command->toArray(), $operation ?: [], 'request');
59
60			$uri = ltrim($operation['requestUri'], '/');
61			if ($result['uri']) {
62			// replace uri
63			$patterns = [];
64			$replacements = [];
65			foreach ($result['uri'] as $key => $value) {
66			$patterns[] = '/{'.$key.'}/';
67			$replacements[] = $value;
68			}
69
70			$uri = preg_replace($patterns, $replacements, $uri);
71			}
72
73			$body = null;
74			if ('rest_json' === $operation['requestProtocol']) {
75			$body = GuzzleHttp\json_encode($result['body']);
76			$result['header']['Content-Type'] = 'application/json';
77			} elseif ('form_params' === $operation['requestProtocol']) {
78			$body = http_build_query($result['body'], '', '&');
79			$result['header']['Content-Type'] = 'application/x-www-form-urlencoded';
80			}
81
82			if ($result['query']) {
83			$uri .= sprintf('?%s', http_build_query($result['query'], null, '&', PHP_QUERY_RFC3986));
84			}
85
86			// GET method has no body, concat to uri
87			if (in_array($operation['httpMethod'], ['GET'])) {
88			// if uri has no query string, append '?' else '&'
89			$uri .= (false === strpos($uri, '?')) ? '?' : '&';
90
91			$uri .= http_build_query($result['body'], null, '&', PHP_QUERY_RFC3986);
92			$result['body'] = null;
93			}
94
95			return new Request(
96			$operation['httpMethod'],
97			$this->service->getEndpoint().$uri,
98			$result['header'],
99			$body
100			);
101			};
102			}
103
104			/**
105			* Transform response to result.
106			*
107			* @return \Closure
108			*/
109			public function responseToResultTransformer()
110			{
111			return function (
112			ResponseInterface $response,
113			RequestInterface $request,
114			CommandInterface $command
115			) {
116			$operation = $this->service->getOperation($command->getName());
117			$this->processResponseError($operation ?: [], $request, $response);
118
119			$body = [];
120			if ('rest_json' === $operation['responseProtocol']) {
121			$body = GuzzleHttp\json_decode($response->getBody(), true);
122			}
123
124			$result = $this->transformData($command, $body, $operation, 'response');
125
126			foreach ($response->getHeaders() as $name => $header) {
127			$result['header'][$name] = is_array($header) ? array_pop($header) : null;
128			}
129
130			return new Result($result['body'], $result['header']);
131			};
132			}
133
134			public function badResponseExceptionParser()
135			{
136			return function (CommandInterface $command, GuzzleBadResponseException $e) {
137			$operation = $this->service->getOperation($command->getName());
138
139			$this->processResponseError(
140			$operation ?: [],
141			$e->getRequest(),
142			$e->getResponse(),
143			$e
144			);
145			};
146			}
147
148			/**
149			* Process response to check is error or not.
150			*
151			* @param array $operation
152			* @param RequestInterface $request
153			* @param ResponseInterface $response
154			* @param GuzzleBadResponseException\|null $e
155			*
156			* @throws \IndraGunawan\RestService\Exception\BadResponseException\|null
157			*/
158			private function processResponseError(
159			array $operation,
160			RequestInterface $request,
161			ResponseInterface $response = null,
162			GuzzleBadResponseException $e = null
163			) {
164			$body = null;
165			if ('rest_json' === $operation['responseProtocol']) {
166			try {
167			$body = GuzzleHttp\json_decode((!is_null($response)) ? $response->getBody() : '', true);
			0 ignored issues – show Bug introduced 2016-08-13 19:31 UTC by Report Bug Copy Issue Report It seems like `!is_null($response) ? $response->getBody() : ''` can also be of type `object<Psr\Http\Message\StreamInterface>`; however, `GuzzleHttp\json_decode()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
168			} catch (\InvalidArgumentException $ex) {
169			throw new BadResponseException(
170			'',
171			$ex->getMessage(),
172			($e ? $e->getMessage() : ''),
173			$request,
174			$response,
175			$e ? $e->getPrevious() : null
176			);
177			}
178			}
179
180			if ($body) {
181			foreach ($operation['errors'] as $name => $error) {
182			if ('field' === $error['type']) {
183			$responseCode = $this->parseError($body, $error['codeField']);
184
185			if (!$responseCode) {
			0 ignored issues – show Bug Best Practice introduced 2016-08-12 17:53 UTC by Report Bug Copy Issue Report The expression `$responseCode` of type `string\|null` is loosely compared to `false`; this is ambiguous if the string can be empty. You might want to explicitly use `=== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
186			continue;
187			}
188
189			// if no ifCode property then return exception
190			if (!$error['ifCode']) {
191			$responseMessage = $this->getErrorMessage($body, $error, $response);
192
193			throw new BadResponseException(
194			$responseCode,
195			$responseMessage,
196			($e ? $e->getMessage() : '').' code: '.$responseCode.', message: '.$responseMessage,
197			$request,
198			$response,
199			$e ? $e->getPrevious() : null
200			);
201			}
202			} else {
203			$responseCode = $response->getStatusCode();
			0 ignored issues – show Bug introduced 2016-08-13 19:31 UTC by Report Bug Copy Issue Report It seems like `$response` is not always an object, but can also be of type `null`. Maybe add an additional type check? If a variable is not always an object, we recommend to add an additional type check to ensure your method call is safe: function someFunction(A $objectMaybe = null) { if ($objectMaybe instanceof A) { $objectMaybe->doSomething(); } } Loading history...
204			}
205
206			if ($this->checkResponseCode($responseCode, $error['operator'], $error['ifCode'])) {
207			$responseMessage = $this->getErrorMessage($body, $error, $response);
208
209			throw new BadResponseException(
210			$responseCode,
211			$responseMessage,
212			($e ? $e->getMessage() : '').'. code: '.$responseCode.', message: '.$responseMessage,
213			$request,
214			$response,
215			$e ? $e->getPrevious() : null
216			);
217			}
218			}
219			}
220			}
221
222			/**
223			* Parse error codeField from body.
224			*
225			* @param array $body
226			* @param string $path
227			*
228			* @return string\|null
229			*/
230			private function parseError(array $body, $path)
231			{
232			$tmp = $body;
233			foreach (explode('.', $path) as $key) {
234			if (!isset($tmp[$key])) {
235			return;
236			}
237
238			$tmp = $tmp[$key];
239			}
240
241			return $tmp;
242			}
243
244			/**
245			* Get error message from posible field.
246			*
247			* @param array $body
248			* @param array $error
249			* @param ResponseInterface\|null $response
250			*
251			* @return string
252			*/
253			private function getErrorMessage(array $body, array $error, ResponseInterface $response = null)
254			{
255			$message = $this->parseError($body, $error['messageField']);
256			if (!$message) {
			0 ignored issues – show Bug Best Practice introduced 2016-08-12 17:53 UTC by Report Bug Copy Issue Report The expression `$message` of type `string\|null` is loosely compared to `false`; this is ambiguous if the string can be empty. You might want to explicitly use `=== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
257			$message = $error['defaultMessage'];
258			}
259			if (!$message) {
260			$message = $response->getReasonPhrase();
			0 ignored issues – show Bug introduced 2016-08-13 19:31 UTC by Report Bug Copy Issue Report It seems like `$response` is not always an object, but can also be of type `null`. Maybe add an additional type check? If a variable is not always an object, we recommend to add an additional type check to ensure your method call is safe: function someFunction(A $objectMaybe = null) { if ($objectMaybe instanceof A) { $objectMaybe->doSomething(); } } Loading history...
261			}
262
263			return $message;
264			}
265
266			/**
267			* Transform and match data with shape.
268			*
269			* @param CommandInterface $command
270			* @param array $datas
271			* @param array $operation
272			* @param string $action
273			*
274			* @return array
275			*/
276			private function transformData(CommandInterface $command, array $datas, array $operation, $action)
277			{
278			$result = [
279			'header' => [],
280			'uri' => [],
281			'query' => [],
282			'body' => [],
283			];
284
285			$validator = new Validator();
286
287			if (isset($operation[$action])) {
288			$shape = $operation[$action];
289			} else {
290			$shape = [
291			'type' => null,
292			'members' => [],
293			];
294			}
295
296			$result['body'] = $this->createData(
297			$validator,
298			$datas,
299			$shape,
300			$command->getName(),
301			$action,
302			$result,
303			('request' === $action) ? $operation['strictRequest'] : $operation['strictResponse'],
304			$operation['sentEmptyField']
305			);
306
307			if (!$validator->validate([$command->getName() => $datas])) {
308			// validation failed
309			throw $validator->createValidatorException();
310			}
311
312			return $result;
313			}
314
315			/**
316			* Create request/response data and add validation rule.
317			*
318			* @param Validator $validator
319			* @param array $datas
320			* @param array $shape
321			* @param string $path
322			* @param string $action
323			* @param array &$result
324			* @param bool $isStrict
325			* @param bool $isSentEmptyField
326			*
327			* @return array
328			*/
329			private function createData(
330			Validator $validator,
331			array &$datas,
332			array $shape,
333			$path,
334			$action,
335			array &$result,
336			$isStrict = false,
337			$isSentEmptyField = true
338			) {
339			$tmpData = $datas;
340			$bodyResult = [];
341			if ('list' === $shape['type']) {
342			$path .= '[*]';
343			}
344
345			foreach ($shape['members'] as $name => $parameter) {
346			$tmpPath = $path.'['.$name.']';
347			$value = isset($datas[$name]) ? $datas[$name] : null;
348			if (!$value) {
349			$datas[$name] = $parameter['defaultValue'];
350			}
351
352			// set validator
353			$validator->add($tmpPath, $parameter, $value);
354
355			// if nested children
356			if (isset($parameter['members']) && count($parameter['members']) > 0) {
357			if (!is_null($value) && !is_array($value)) {
358			throw new ValidatorException($tmpPath, sprintf(
359			'Expected "%s", but got "%s"',
360			$parameter['type'],
361			gettype($value)
362			));
363			}
364			if ('list' === $parameter['type']) {
365			$children = $value ?: [];
366			foreach ($children as $idx => $child) {
367			if (!is_array($child)) {
368			throw new ValidatorException($tmpPath, 'Expected "list", but got "map"');
369			}
370
371			$bodyResult[$parameter['locationName']][] = $this->createData(
372			$validator,
373			$datas[$name][$idx],
374			$parameter,
375			$tmpPath,
376			$action,
377			$result,
378			$isStrict,
379			$isSentEmptyField
380			);
381			}
382			} elseif ('map' === $parameter['type']) {
383			if (is_null($value)) {
384			if (array_key_exists($name, $datas)) {
385			unset($tmpData[$name]);
386			}
387			continue;
388			}
389			$children = $value ?: [];
390			foreach (array_keys($parameter['members']) as $key) {
391			if (!array_key_exists($key, $children)) {
392			$children[$key] = null;
393			$datas[$name][$key] = null;
394			}
395			}
396
397			$bodyResult[$parameter['locationName']] = $this->createData(
398			$validator,
399			$datas[$name],
400			$parameter,
401			$tmpPath,
402			$action,
403			$result,
404			$isStrict,
405			$isSentEmptyField
406			);
407			}
408			}
409
410			$formattedValue = $this->formatter->format($parameter['type'], $parameter['format'], $value, $parameter['defaultValue']);
411			if ('body' !== $parameter['location']) {
412			$result[$parameter['location']][$parameter['locationName']] = $formattedValue;
413			} else {
414			if (!array_key_exists($parameter['locationName'], $bodyResult)) {
415			if (!$value && !is_numeric($value)) {
416			$value = $parameter['defaultValue'];
417			}
418			if ($isSentEmptyField \|\| ($value \|\| is_numeric($value))) {
419			$bodyResult[$parameter['locationName']] = $formattedValue;
420			}
421			}
422			}
423			unset($tmpData[$name]);
424			}
425
426			if (count($tmpData) > 0) {
427			if ($isStrict) {
428			throw new BadRequestException(ucwords($action), 'Undefined parameters "'.implode('", "', array_keys($tmpData)).'"');
429			}
430			foreach ($tmpData as $name => $child) {
431			$bodyResult[$name] = $child;
432			}
433			}
434
435			return $bodyResult;
436			}
437
438			/**
439			* Check is responsecode is match with code.
440			*
441			* @param string $responseCode
442			* @param string $operator
443			* @param string $code
444			*
445			* @return bool
446			*/
447			public function checkResponseCode($responseCode, $operator, $code)
448			{
449			switch ($operator) {
450			case '===':
451			return $responseCode === $code;
452			case '!==':
453			return $responseCode !== $code;
454			case '!=':
455			return $responseCode != $code;
456			case '<':
457			return $responseCode < $code;
458			case '<=':
459			return $responseCode <= $code;
460			case '>=':
461			return $responseCode >= $code;
462			case '>':
463			return $responseCode > $code;
464			default:
465			return $responseCode == $code;
466			}
467			}
468			}
469

indragunawan / rest-service

Push — master ( b8a64c...327515 )

Builder::commandToRequestTransformer() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like