Builder::commandToRequestTransformer() - Code Metrics - Inspection of "Fix some scrutinizer issues" - indragunawan/rest-service - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2ed0f3...63bd6b )

by Indra

created 2016-08-13 19:28 UTC

Builder::commandToRequestTransformer() C

↳ Parent: Builder

Complexity

Conditions	8
Paths	1

Size

Total Lines	51
Code Lines	32

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	72

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
c	2
b	0
f	1
dl	0
loc	51
ccs	0
cts	42
cp	0
rs	6.5978
cc	8
eloc	32
nc	1
nop	0
crap	72

How to fix Long Method

<?php

namespace IndraGunawan\RestService;

use GuzzleHttp;
use GuzzleHttp\Command\CommandInterface;
use GuzzleHttp\Exception\BadResponseException as GuzzleBadResponseException;
use GuzzleHttp\Psr7\Request;
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;

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

    /**
     * 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));
            }

            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());

            return $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
     *
     * @return 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) {
                return 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);

                        return 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 ($error['ifCode'] == $responseCode) {
                    $responseMessage = $this->getErrorMessage($body, $error, $response);

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

        return;
    }

    /**
     * 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 && $response->getStatusCode() >= 400) {
            $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
        );

        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
     *
     * @return array
     */
    private function createData(
        Validator $validator,
        array $datas,
        array $shape,
        $path,
        $action,
        array &$result
    ) {
        $bodyResult = [];
        if ('list' === $shape['type']) {
            $path .= '[*]';
        }

        foreach ($shape['members'] as $name => $parameter) {
            $tmpPath = $path.'['.$name.']';
            $value = isset($datas[$name]) ? $datas[$name] : null;
            // 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, $child, $parameter, $tmpPath, $action, $result);
                    }
                } elseif ('map' === $parameter['type']) {
                    if (is_null($value)) {
                        continue;
                    }
                    $children = $value ?: [];
                    foreach (array_keys($parameter['members']) as $key) {
                        if (!array_key_exists($key, $children)) {
                            $children[$key] = null;
                        }
                    }

                    foreach ($children as $parameterName => $child) {
                        if (is_array($child)) {
                            $bodyResult[$parameter['locationName']][$parameterName] = $this->createData(
                                $validator,
                                $child,
                                $parameter,
                                $tmpPath,
                                $action,
                                $result
                            );
                        }
                    }
                    $bodyResult[$parameter['locationName']] = $this->createData(
                        $validator,
                        $children,
                        $parameter,
                        $tmpPath,
                        $action,
                        $result
                    );
                }
            }

            $value = $this->getFormatedValue($value, $parameter, $action);
            if ('body' !== $parameter['location']) {
                $result[$parameter['location']][$parameter['locationName']] = $value;
            } else {
                if (!array_key_exists($parameter['locationName'], $bodyResult)) {
                    $bodyResult[$parameter['locationName']] = $value;
                }
            }
            unset($datas[$name]);
        }

        if (count($datas) > 0) {
            foreach ($datas as $name => $child) {
                $bodyResult[$name] = $child;
            }
        }

        return $bodyResult;
    }

    /**
     * Get formatted value.
     *
     * @param mixed  $value     [description]
     * @param array  $parameter [description]
     * @param string $action    request/response
     *
     * @return mixed
     */
    private function getFormatedValue($value, array $parameter, $action)
    {
        if (!$value) {
            $value = $parameter['defaultValue'];
        }

        switch ($parameter['type']) {
            case 'integer':
                return (int) (string) $value;
            case 'float':
                return (float) (string) $value;
            case 'string':
                $result = (string) $value;

                return sprintf($parameter['format'] ?: '%s', $result);
            case 'boolean':
                return ($value === 'true' || true === $value) ? true : false;
            case 'number':
                if ($parameter['format']) {
                    $format = explode('|', $parameter['format']);
                    $decimal = isset($format[0]) ? $format[0] : 0;
                    $decimalPoint = isset($format[1]) ? $format[1] : '.';
                    $thousandsSeparator = isset($format[2]) ? $format[2] : ',';

                    return number_format((float) (string) $value, $decimal, $decimalPoint, $thousandsSeparator);
                }

                return (string) $value;
            case 'datetime':
                if ('request' === $action) {
                    if (!$value) {
                        return;
                    }

                    if (!($value instanceof \DateTime)) {
                        $value = new \DateTime($value);
                    }

                    if ($parameter['format']) {
                        return $value->format($parameter['format']);
                    }

                    return $value->format('Y-m-d\TH:i:s\Z');
                } elseif ('response' === $action) {
                    if ($parameter['format']) {
                        return \DateTime::createFromFormat($parameter['format'], $value);
                    } else {
                        return new \DateTime($value);
                    }
                }
                //
            default:
                return;
        }
    }
}


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\BadResponseException;
10			use IndraGunawan\RestService\Exception\CommandException;
11			use IndraGunawan\RestService\Exception\ValidatorException;
12			use IndraGunawan\RestService\Validator\Validator;
13			use Psr\Http\Message\RequestInterface;
14			use Psr\Http\Message\ResponseInterface;
15
16			class Builder
17			{
18			/**
19			* @var ServiceInterface
20			*/
21			private $service;
22
23			/**
24			* @param ServiceInterface $service
25			*/
26			public function __construct(ServiceInterface $service)
27			{
28			$this->service = $service;
29			}
30
31			/**
32			* Transform command to request.
33			*
34			* @return \Closure
35			*/
36			public function commandToRequestTransformer()
37			{
38			return function (CommandInterface $command) {
39			if (!$this->service->hasOperation($command->getName())) {
40			throw new CommandException(
41			sprintf(
42			'Command "%s" not found',
43			$command->getName()
44			),
45			$command
46			);
47			}
48
49			$operation = $this->service->getOperation($command->getName());
50
51			$result = $this->transformData($command, $command->toArray(), $operation ?: [], 'request');
52
53			$uri = ltrim($operation['requestUri'], '/');
54			if ($result['uri']) {
55			// replace uri
56			$patterns = [];
57			$replacements = [];
58			foreach ($result['uri'] as $key => $value) {
59			$patterns[] = '/{'.$key.'}/';
60			$replacements[] = $value;
61			}
62
63			$uri = preg_replace($patterns, $replacements, $uri);
64			}
65
66			$body = null;
67			if ('rest_json' === $operation['requestProtocol']) {
68			$body = GuzzleHttp\json_encode($result['body']);
69			$result['header']['Content-Type'] = 'application/json';
70			} elseif ('form_params' === $operation['requestProtocol']) {
71			$body = http_build_query($result['body'], '', '&');
72			$result['header']['Content-Type'] = 'application/x-www-form-urlencoded';
73			}
74
75			if ($result['query']) {
76			$uri .= sprintf('?%s', http_build_query($result['query'], null, '&', PHP_QUERY_RFC3986));
77			}
78
79			return new Request(
80			$operation['httpMethod'],
81			$this->service->getEndpoint().$uri,
82			$result['header'],
83			$body
84			);
85			};
86			}
87
88			/**
89			* Transform response to result.
90			*
91			* @return \Closure
92			*/
93			public function responseToResultTransformer()
94			{
95			return function (
96			ResponseInterface $response,
97			RequestInterface $request,
98			CommandInterface $command
99			) {
100			$operation = $this->service->getOperation($command->getName());
101			$this->processResponseError($operation ?: [], $request, $response);
102
103			$body = [];
104			if ('rest_json' === $operation['responseProtocol']) {
105			$body = GuzzleHttp\json_decode($response->getBody(), true);
106			}
107
108			$result = $this->transformData($command, $body, $operation, 'response');
109
110			foreach ($response->getHeaders() as $name => $header) {
111			$result['header'][$name] = is_array($header) ? array_pop($header) : null;
112			}
113
114			return new Result($result['body'], $result['header']);
115			};
116			}
117
118			public function badResponseExceptionParser()
119			{
120			return function (CommandInterface $command, GuzzleBadResponseException $e) {
121			$operation = $this->service->getOperation($command->getName());
122
123			return $this->processResponseError(
124			$operation ?: [],
125			$e->getRequest(),
126			$e->getResponse(),
127			$e
128			);
129			};
130			}
131
132			/**
133			* Process response to check is error or not.
134			*
135			* @param array $operation
136			* @param RequestInterface $request
137			* @param ResponseInterface $response
138			* @param GuzzleBadResponseException\|null $e
139			*
140			* @return BadResponseException\|null
141			*/
142			private function processResponseError(
143			array $operation,
144			RequestInterface $request,
145			ResponseInterface $response = null,
146			GuzzleBadResponseException $e = null
147			) {
148			$body = null;
149			if ('rest_json' === $operation['responseProtocol']) {
150			try {
151			$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...
152			} catch (\InvalidArgumentException $ex) {
153			return new BadResponseException(
154			'',
155			$ex->getMessage(),
156			($e ? $e->getMessage() : ''),
157			$request,
158			$response,
159			$e ? $e->getPrevious() : null
160			);
161			}
162			}
163
164			if ($body) {
165			foreach ($operation['errors'] as $name => $error) {
166			if ('field' === $error['type']) {
167			$responseCode = $this->parseError($body, $error['codeField']);
168
169			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...
170			continue;
171			}
172
173			// if no ifCode property then return exception
174			if (!$error['ifCode']) {
175			$responseMessage = $this->getErrorMessage($body, $error, $response);
176
177			return new BadResponseException(
178			$responseCode,
179			$responseMessage,
180			($e ? $e->getMessage() : '').' code: '.$responseCode.', message: '.$responseMessage,
181			$request,
182			$response,
183			$e ? $e->getPrevious() : null
184			);
185			}
186			} else {
187			$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...
188			}
189
190			if ($error['ifCode'] == $responseCode) {
191			$responseMessage = $this->getErrorMessage($body, $error, $response);
192
193			return 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			}
203			}
204
205			return;
206			}
207
208			/**
209			* Parse error codeField from body.
210			*
211			* @param array $body
212			* @param string $path
213			*
214			* @return string\|null
215			*/
216			private function parseError(array $body, $path)
217			{
218			$tmp = $body;
219			foreach (explode('.', $path) as $key) {
220			if (!isset($tmp[$key])) {
221			return;
222			}
223
224			$tmp = $tmp[$key];
225			}
226
227			return $tmp;
228			}
229
230			/**
231			* Get error message from posible field.
232			*
233			* @param array $body
234			* @param array $error
235			* @param ResponseInterface\|null $response
236			*
237			* @return string
238			*/
239			private function getErrorMessage(array $body, array $error, ResponseInterface $response = null)
240			{
241			$message = $this->parseError($body, $error['messageField']);
242			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...
243			$message = $error['defaultMessage'];
244			}
245			if (!$message && $response->getStatusCode() >= 400) {
246			$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...
247			}
248
249			return $message;
250			}
251
252			/**
253			* Transform and match data with shape.
254			*
255			* @param CommandInterface $command
256			* @param array $datas
257			* @param array $operation
258			* @param string $action
259			*
260			* @return array
261			*/
262			private function transformData(CommandInterface $command, array $datas, array $operation, $action)
263			{
264			$result = [
265			'header' => [],
266			'uri' => [],
267			'query' => [],
268			'body' => [],
269			];
270
271			$validator = new Validator();
272
273			if (isset($operation[$action])) {
274			$shape = $operation[$action];
275			} else {
276			$shape = [
277			'type' => null,
278			'members' => [],
279			];
280			}
281
282			$result['body'] = $this->createData(
283			$validator,
284			$datas,
285			$shape,
286			$command->getName(),
287			$action,
288			$result
289			);
290
291			if (!$validator->validate([$command->getName() => $datas])) {
292			// validation failed
293			throw $validator->createValidatorException();
294			}
295
296			return $result;
297			}
298
299			/**
300			* Create request/response data and add validation rule.
301			*
302			* @param Validator $validator
303			* @param array $datas
304			* @param array $shape
305			* @param string $path
306			* @param string $action
307			* @param array &$result
308			*
309			* @return array
310			*/
311			private function createData(
312			Validator $validator,
313			array $datas,
314			array $shape,
315			$path,
316			$action,
317			array &$result
318			) {
319			$bodyResult = [];
320			if ('list' === $shape['type']) {
321			$path .= '[*]';
322			}
323
324			foreach ($shape['members'] as $name => $parameter) {
325			$tmpPath = $path.'['.$name.']';
326			$value = isset($datas[$name]) ? $datas[$name] : null;
327			// set validator
328			$validator->add($tmpPath, $parameter, $value);
329
330			// if nested children
331			if (isset($parameter['members']) && count($parameter['members']) > 0) {
332			if (!is_null($value) && !is_array($value)) {
333			throw new ValidatorException($tmpPath, sprintf(
334			'Expected "%s", but got "%s"',
335			$parameter['type'],
336			gettype($value)
337			));
338			}
339			if ('list' === $parameter['type']) {
340			$children = $value ?: [];
341			foreach ($children as $idx => $child) {
342			if (!is_array($child)) {
343			throw new ValidatorException($tmpPath, 'Expected "list", but got "map"');
344			}
345
346			$bodyResult[$parameter['locationName']][] = $this->createData($validator, $child, $parameter, $tmpPath, $action, $result);
347			}
348			} elseif ('map' === $parameter['type']) {
349			if (is_null($value)) {
350			continue;
351			}
352			$children = $value ?: [];
353			foreach (array_keys($parameter['members']) as $key) {
354			if (!array_key_exists($key, $children)) {
355			$children[$key] = null;
356			}
357			}
358
359			foreach ($children as $parameterName => $child) {
360			if (is_array($child)) {
361			$bodyResult[$parameter['locationName']][$parameterName] = $this->createData(
362			$validator,
363			$child,
364			$parameter,
365			$tmpPath,
366			$action,
367			$result
368			);
369			}
370			}
371			$bodyResult[$parameter['locationName']] = $this->createData(
372			$validator,
373			$children,
374			$parameter,
375			$tmpPath,
376			$action,
377			$result
378			);
379			}
380			}
381
382			$value = $this->getFormatedValue($value, $parameter, $action);
383			if ('body' !== $parameter['location']) {
384			$result[$parameter['location']][$parameter['locationName']] = $value;
385			} else {
386			if (!array_key_exists($parameter['locationName'], $bodyResult)) {
387			$bodyResult[$parameter['locationName']] = $value;
388			}
389			}
390			unset($datas[$name]);
391			}
392
393			if (count($datas) > 0) {
394			foreach ($datas as $name => $child) {
395			$bodyResult[$name] = $child;
396			}
397			}
398
399			return $bodyResult;
400			}
401
402			/**
403			* Get formatted value.
404			*
405			* @param mixed $value [description]
406			* @param array $parameter [description]
407			* @param string $action request/response
408			*
409			* @return mixed
410			*/
411			private function getFormatedValue($value, array $parameter, $action)
412			{
413			if (!$value) {
414			$value = $parameter['defaultValue'];
415			}
416
417			switch ($parameter['type']) {
418			case 'integer':
419			return (int) (string) $value;
420			case 'float':
421			return (float) (string) $value;
422			case 'string':
423			$result = (string) $value;
424
425			return sprintf($parameter['format'] ?: '%s', $result);
426			case 'boolean':
427			return ($value === 'true' \|\| true === $value) ? true : false;
428			case 'number':
429			if ($parameter['format']) {
430			$format = explode('\|', $parameter['format']);
431			$decimal = isset($format[0]) ? $format[0] : 0;
432			$decimalPoint = isset($format[1]) ? $format[1] : '.';
433			$thousandsSeparator = isset($format[2]) ? $format[2] : ',';
434
435			return number_format((float) (string) $value, $decimal, $decimalPoint, $thousandsSeparator);
436			}
437
438			return (string) $value;
439			case 'datetime':
440			if ('request' === $action) {
441			if (!$value) {
442			return;
443			}
444
445			if (!($value instanceof \DateTime)) {
446			$value = new \DateTime($value);
447			}
448
449			if ($parameter['format']) {
450			return $value->format($parameter['format']);
451			}
452
453			return $value->format('Y-m-d\TH:i:s\Z');
454			} elseif ('response' === $action) {
455			if ($parameter['format']) {
456			return \DateTime::createFromFormat($parameter['format'], $value);
457			} else {
458			return new \DateTime($value);
459			}
460			}
461			//
462			default:
463			return;
464			}
465			}
466			}
467

indragunawan / rest-service

Push — master ( 2ed0f3...63bd6b )

Builder::commandToRequestTransformer() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like