AbstractApiRequest::mapResult() - Code Metrics - Inspection of "Merge branch 'release/v2.10.0'" - commercetools/commercetools-php-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3f8301...c7321f )

by Jens

created 2020-04-02 09:32 UTC

AbstractApiRequest::mapResult() A

↳ Parent: AbstractApiRequest

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	1
nc	1
nop	2
crap	1

<?php
/**
 * @author @jenschude <[email protected]>
 * @created: 26.01.15, 11:00
 */

namespace Commercetools\Core\Request;

use Commercetools\Core\Model\Common\JsonObject;
use Commercetools\Core\Model\JsonObjectMapper;
use Commercetools\Core\Model\MapperInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Commercetools\Core\Client;
use Commercetools\Core\Client\JsonEndpoint;
use Commercetools\Core\Model\Common\Context;
use Commercetools\Core\Model\Common\ContextAwareInterface;
use Commercetools\Core\Model\Common\ContextTrait;
use Commercetools\Core\Model\Common\JsonDeserializeInterface;
use Commercetools\Core\Request\Query\MultiParameter;
use Commercetools\Core\Request\Query\Parameter;
use Commercetools\Core\Request\Query\ParameterInterface;
use Commercetools\Core\Response\ApiResponseInterface;

/**
 * @package Commercetools\Core\Request
 */
abstract class AbstractApiRequest implements ClientRequestInterface, ContextAwareInterface
{
    const EXTERNAL_USER_HEADER = 'X-External-User-ID';
    use ContextTrait;

    /**
     * @var JsonEndpoint
     */
    protected $endpoint;

    /**
     * @var array
     */
    protected $params = [];

    protected $identifier;

    protected $resultClass = JsonObject::class;

    protected $externalUserId = null;

    /**
     * @param JsonEndpoint $endpoint
     * @param Context $context
     */
    public function __construct(JsonEndpoint $endpoint, Context $context = null)
    {
        $this->setContext($context);
        $this->setEndpoint($endpoint);
    }

    /**
     * @return int
     */
    public function getParamCount()
    {
        return count($this->params);
    }

    /**
     * @return string
     * @internal
     */
    public function getResultClass()
    {
        return $this->resultClass;
    }

    /**
     * @return string
     */
    public function getIdentifier()
    {
        if (is_null($this->identifier)) {
            $this->identifier = uniqid();
        }

        return $this->identifier;
    }

    /**
     * @param string $identifier
     * @return $this
     */
    public function setIdentifier($identifier)
    {
        $this->identifier = $identifier;

        return $this;
    }

    /**
     * @param string|null $externalUserId
     * @return $this
     */
    public function setExternalUserId($externalUserId)
    {
        $this->externalUserId = $externalUserId;

        return $this;
    }

    /**
     * @param JsonEndpoint $endpoint
     * @return $this
     * @internal
     */
    protected function setEndpoint(JsonEndpoint $endpoint)
    {
        $this->endpoint = $endpoint;

        return $this;
    }

    /**
     * @return JsonEndpoint
     * @internal
     */
    public function getEndpoint()
    {
        return $this->endpoint;
    }

    /**
     * @param $key
     * @param $value
     * @param bool $replace
     * @return $this
     */
    public function addParam($key, $value = null, $replace = true)
    {
        if ($replace) {
            $param = new Parameter($key, $value);
        } else {
            $param = new MultiParameter($key, $value);
        }

        return $this->addParamObject($param);
    }

    /**
     * @param ParameterInterface $param
     * @return $this
     */
    public function addParamObject(ParameterInterface $param)
    {
        $this->params[$param->getId()] = $param;

        return $this;
    }

    protected function convertToString($params)
    {
        $params = array_map(
            function ($param) {
                return (string)$param;
            },
            $params
        );
        ksort($params);
        $params = implode('&', $params);

        return $params;
    }
    /**
     * @return string
     * @internal
     */
    protected function getParamString()
    {
        $params = $this->convertToString($this->params);

        return (!empty($params) ? '?' . $params : '');
    }

    /**
     * @return string
     * @internal
     */
    protected function getPath()
    {
        return (string)$this->getEndpoint() . $this->getParamString();
    }

    /**
     * @param ResponseInterface $response
     * @return ApiResponseInterface
     * @internal
     */
    abstract public function buildResponse(ResponseInterface $response);

    /**
     * @return RequestInterface
     * @internal
     */
    abstract public function httpRequest();


    /**
     * @param array $result
     * @param Context $context
     * @return JsonDeserializeInterface|null
     * @internal
     * @deprecated Use map() instead
     */
    public function mapResult(array $result, Context $context = null)
    {
        return $this->map($result, $context);
    }

    /**
     * @param ApiResponseInterface $response
     * @return JsonDeserializeInterface|null
     * @deprecated Use mapFromResponse() instead
     */
    public function mapResponse(ApiResponseInterface $response)
    {
        return $this->mapFromResponse($response);
    }

    /**
     * @inheritdoc
     */
    public function mapFromResponse($response, MapperInterface $mapper = null)
    {
        if ($response instanceof ResponseInterface) {
            $response = $this->buildResponse($response);
        }
        if ($response->isError()) {
            return null;
        }
        $result = $response->toArray();
        if ($response instanceof ContextAwareInterface) {
            return $this->map($result, $response->getContext(), $mapper);
        }

        return $this->map($result, $this->getContext(), $mapper);
    }

    public function map(array $data, Context $context = null, MapperInterface $mapper = null)
    {
        if (!empty($data)) {
            if (is_null($mapper)) {
                $mapper = JsonObjectMapper::of($context);
            }
            return $mapper->map($data, $this->resultClass);
        }

        return null;
    }

    /**
     * @param Client $client
     * @param array|null $headers
     * @return ApiResponseInterface
     * @throws \Commercetools\Core\Error\ApiException
     */
    public function executeWithClient(Client $client, array $headers = null)
    {
        if (!is_null($this->externalUserId) && !isset($headers[self::EXTERNAL_USER_HEADER])) {
            $headers[self::EXTERNAL_USER_HEADER] = $this->externalUserId;
        }
        return $client->execute($this, $headers);
    }
}


1		<?php
2		/**
3		* @author @jenschude <[email protected]>
4		* @created: 26.01.15, 11:00
5		*/
6
7		namespace Commercetools\Core\Request;
8
9		use Commercetools\Core\Model\Common\JsonObject;
10		use Commercetools\Core\Model\JsonObjectMapper;
11		use Commercetools\Core\Model\MapperInterface;
12		use Psr\Http\Message\RequestInterface;
13		use Psr\Http\Message\ResponseInterface;
14		use Commercetools\Core\Client;
15		use Commercetools\Core\Client\JsonEndpoint;
16		use Commercetools\Core\Model\Common\Context;
17		use Commercetools\Core\Model\Common\ContextAwareInterface;
18		use Commercetools\Core\Model\Common\ContextTrait;
19		use Commercetools\Core\Model\Common\JsonDeserializeInterface;
20		use Commercetools\Core\Request\Query\MultiParameter;
21		use Commercetools\Core\Request\Query\Parameter;
22		use Commercetools\Core\Request\Query\ParameterInterface;
23		use Commercetools\Core\Response\ApiResponseInterface;
24
25		/**
26		* @package Commercetools\Core\Request
27		*/
28		abstract class AbstractApiRequest implements ClientRequestInterface, ContextAwareInterface
29		{
30		const EXTERNAL_USER_HEADER = 'X-External-User-ID';
31		use ContextTrait;
32
33		/**
34		* @var JsonEndpoint
35		*/
36		protected $endpoint;
37
38		/**
39		* @var array
40		*/
41		protected $params = [];
42
43		protected $identifier;
44
45		protected $resultClass = JsonObject::class;
46
47		protected $externalUserId = null;
48
49		/**
50		* @param JsonEndpoint $endpoint
51		* @param Context $context
52		*/
53	1617	public function __construct(JsonEndpoint $endpoint, Context $context = null)
54		{
55	1617	$this->setContext($context);
56	1617	$this->setEndpoint($endpoint);
57	1617	}
58
59		/**
60		* @return int
61		*/
62	3	public function getParamCount()
63		{
64	3	return count($this->params);
65		}
66
67		/**
68		* @return string
69		* @internal
70		*/
71		public function getResultClass()
72		{
73		return $this->resultClass;
74		}
75
76		/**
77		* @return string
78		*/
79	186	public function getIdentifier()
80		{
81	186	if (is_null($this->identifier)) {
82	185	$this->identifier = uniqid();
83		}
84
85	186	return $this->identifier;
86		}
87
88		/**
89		* @param string $identifier
90		* @return $this
91		*/
92	1	public function setIdentifier($identifier)
93		{
94	1	$this->identifier = $identifier;
95
96	1	return $this;
97		}
98
99		/**
100		* @param string\|null $externalUserId
101		* @return $this
102		*/
103		public function setExternalUserId($externalUserId)
104		{
105		$this->externalUserId = $externalUserId;
106
107		return $this;
108		}
109
110		/**
111		* @param JsonEndpoint $endpoint
112		* @return $this
113		* @internal
114		*/
115	1617	protected function setEndpoint(JsonEndpoint $endpoint)
116		{
117	1617	$this->endpoint = $endpoint;
118
119	1617	return $this;
120		}
121
122		/**
123		* @return JsonEndpoint
124		* @internal
125		*/
126	959	public function getEndpoint()
127		{
128	959	return $this->endpoint;
129		}
130
131		/**
132		* @param $key
133		* @param $value
134		* @param bool $replace
135		* @return $this
136		*/
137	89	public function addParam($key, $value = null, $replace = true)
138		{
139	89	if ($replace) {
140	77	$param = new Parameter($key, $value);
141		} else {
142	13	$param = new MultiParameter($key, $value);
143		}
144
145	88	return $this->addParamObject($param);
146		}
147
148		/**
149		* @param ParameterInterface $param
150		* @return $this
151		*/
152	971	public function addParamObject(ParameterInterface $param)
153		{
154	971	$this->params[$param->getId()] = $param;
155
156	971	return $this;
157		}
158
159	964	protected function convertToString($params)
160		{
161	964	$params = array_map(
162		function ($param) {
163	833	return (string)$param;
164	964	},
165		$params
166		);
167	964	ksort($params);
168	964	$params = implode('&', $params);
169
170	964	return $params;
171		}
172		/**
173		* @return string
174		* @internal
175		*/
176	923	protected function getParamString()
177		{
178	923	$params = $this->convertToString($this->params);
179
180	923	return (!empty($params) ? '?' . $params : '');
181		}
182
183		/**
184		* @return string
185		* @internal
186		*/
187	806	protected function getPath()
188		{
189	806	return (string)$this->getEndpoint() . $this->getParamString();
190		}
191
192		/**
193		* @param ResponseInterface $response
194		* @return ApiResponseInterface
195		* @internal
196		*/
197		abstract public function buildResponse(ResponseInterface $response);
198
199		/**
200		* @return RequestInterface
201		* @internal
202		*/
203		abstract public function httpRequest();
204
205
206		/**
207		* @param array $result
208		* @param Context $context
209		* @return JsonDeserializeInterface\|null
210		* @internal
211		* @deprecated Use map() instead
212		*/
213	407	public function mapResult(array $result, Context $context = null)
214		{
215	407	return $this->map($result, $context);
216		}
217
218		/**
219		* @param ApiResponseInterface $response
220		* @return JsonDeserializeInterface\|null
221		* @deprecated Use mapFromResponse() instead
222		*/
223	203	public function mapResponse(ApiResponseInterface $response)
224		{
225	203	return $this->mapFromResponse($response);
226		}
227
228		/**
229		* @inheritdoc
230		*/
231	740	public function mapFromResponse($response, MapperInterface $mapper = null)
232		{
233	740	if ($response instanceof ResponseInterface) {
234	550	$response = $this->buildResponse($response);
235		}
236	740	if ($response->isError()) {
237	7	return null;
238		}
239	739	$result = $response->toArray();
240	739	if ($response instanceof ContextAwareInterface) {
241	739	return $this->map($result, $response->getContext(), $mapper);
242		}
243
244		return $this->map($result, $this->getContext(), $mapper);
245		}
246
247	1074	public function map(array $data, Context $context = null, MapperInterface $mapper = null)
248		{
249	1074	if (!empty($data)) {
250	905	if (is_null($mapper)) {
251	905	$mapper = JsonObjectMapper::of($context);
252		}
253	905	return $mapper->map($data, $this->resultClass);
254		}
255
256	169	return null;
257		}
258
259		/**
260		* @param Client $client
261		* @param array\|null $headers
262		* @return ApiResponseInterface
263		* @throws \Commercetools\Core\Error\ApiException
264		*/
265	203	public function executeWithClient(Client $client, array $headers = null)
266		{
267	203	if (!is_null($this->externalUserId) && !isset($headers[self::EXTERNAL_USER_HEADER])) {
268		$headers[self::EXTERNAL_USER_HEADER] = $this->externalUserId;
269		}
270	203	return $client->execute($this, $headers);
271		}
272		}
273

commercetools / commercetools-php-sdk

Push — master ( 3f8301...c7321f )

AbstractApiRequest::mapResult() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like