SdkClient::__construct() - Code Metrics - Inspection of "Throw exception if attribute is not set (#85)" - mapado/rest-client-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cc21f4...3eeaf5 )

by Julien

created 2019-01-31 10:27 UTC

SdkClient::__construct() A

↳ Parent: SdkClient

Complexity

Conditions	3
Paths	4

Size

Total Lines	19
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	3.072

Importance

Changes

Metric	Value
cc	3
eloc	10
nc	4
nop	4
dl	0
loc	19
ccs	8
cts	10
cp	0.8
crap	3.072
rs	9.9332
c	0
b	0
f	0

<?php

namespace Mapado\RestClientSdk;

use Mapado\RestClientSdk\Model\ModelHydrator;
use Mapado\RestClientSdk\Model\Serializer;
use ProxyManager\Configuration;
use ProxyManager\Factory\LazyLoadingGhostFactory;
use ProxyManager\Proxy\GhostObjectInterface;
use Psr\Cache\CacheItemPoolInterface;

/**
 * Sdk Client
 */
class SdkClient
{
    /**
     * @var RestClient
     */
    protected $restClient;

    /**
     * Cache item pool.
     *
     * @var ?CacheItemPoolInterface
     */
    protected $cacheItemPool;

    /**
     * Cache prefix.
     *
     * @var string
     */
    protected $cachePrefix;

    /**
     * @var Mapping
     */
    private $mapping;

    /**
     * @var Serializer
     */
    private $serializer;

    /**
     * @var ModelHydrator
     */
    private $modelHydrator;

    /**
     * @var array
     */
    private $repositoryList = [];

    /**
     * proxyManagerConfig
     *
     * @var ?Configuration
     */
    private $proxyManagerConfig;

    /**
     * unitOfWork
     *
     * @var UnitOfWork
     */
    private $unitOfWork;

    /**
     * Constructor.
     *
     * @param RestClient      $restClient
     * @param Mapping         $mapping
     * @param UnitOfWork|null $unitOfWork
     * @param Serializer|null $serializer
     */
    public function __construct(
        RestClient $restClient,
        Mapping $mapping,
        UnitOfWork $unitOfWork = null,
        Serializer $serializer = null
    ) {
        $this->restClient = $restClient;
        $this->mapping = $mapping;
        if (!$unitOfWork) {
            $unitOfWork = new UnitOfWork($this->mapping);
        }
        $this->unitOfWork = $unitOfWork;
        if (!$serializer) {
            $serializer = new Serializer($this->mapping, $this->unitOfWork);
        }
        $this->serializer = $serializer;
        $this->serializer->setSdk($this);

        $this->modelHydrator = new ModelHydrator($this);
    }

    /**
     * setCacheItemPool
     *
     * @param CacheItemPoolInterface $cacheItemPool
     *
     * @return SdkClient
     */
    public function setCacheItemPool(
        CacheItemPoolInterface $cacheItemPool,
        $cachePrefix = ''
    ) {
        $this->cacheItemPool = $cacheItemPool;
        $this->cachePrefix = $cachePrefix;

        return $this;
    }

    /**
     * getCacheItemPool
     *
     * @return ?CacheItemPoolInterface
     */
    public function getCacheItemPool()
    {
        return $this->cacheItemPool;
    }

    /**
     * getCachePrefix
     *
     * @return string
     */
    public function getCachePrefix()
    {
        return $this->cachePrefix;
    }

    /**
     * getRepository
     *
     * @param string $modelName
     *
     * @return EntityRepository
     */
    public function getRepository($modelName)
    {
        // get repository by key
        $metadata = $this->mapping->getClassMetadataByKey($modelName);
        if (!$metadata) {
            // get by classname
            $metadata = $this->mapping->getClassMetadata($modelName);
        }

        $modelName = $metadata->getModelName();

        if (!isset($this->repositoryList[$modelName])) {
            $repositoryName =
                $metadata->getRepositoryName()
                ?: '\Mapado\RestClientSdk\EntityRepository';
            $this->repositoryList[$modelName] = new $repositoryName(
                $this,
                $this->restClient,
                $this->unitOfWork,
                $modelName
            );
        }

        return $this->repositoryList[$modelName];
    }

    /**
     * getRestClient
     *
     * @return RestClient
     */
    public function getRestClient()
    {
        return $this->restClient;
    }

    /**
     * getMapping
     *
     * @return Mapping
     */
    public function getMapping()
    {
        return $this->mapping;
    }

    /**
     * getSerializer
     *
     * @return Serializer
     */
    public function getSerializer()
    {
        return $this->serializer;
    }

    /**
     * getModelHydrator
     *
     * @return ModelHydrator
     */
    public function getModelHydrator()
    {
        return $this->modelHydrator;
    }

    /**
     * createProxy
     *
     * @param string $id
     *
     * @return \ProxyManager\Proxy\GhostObjectInterface
     */
    public function createProxy($id)
    {
        $key = $this->mapping->getKeyFromId($id);
        $classMetadata = $this->mapping->getClassMetadataByKey($key);

        if (null === $classMetadata) {
            throw new \RuntimeException(
                "Unable to get classMetadata for key {$key}. This should not happen."
            );
        }

        $modelName = $classMetadata->getModelName();

        $sdk = $this;

        if ($this->proxyManagerConfig) {
            $factory = new LazyLoadingGhostFactory($this->proxyManagerConfig);
        } else {
            $factory = new LazyLoadingGhostFactory();
        }

        $proxyModelName = preg_replace('/^\\\\*/', '', $modelName);

        $initializer = function (
            GhostObjectInterface $proxy,
            string $method,
            array $parameters,
            &$initializer,
            array $properties
        ) use ($sdk, $classMetadata, $id, $proxyModelName) {
            $isAllowedMethod =
                'jsonSerialize' === $method ||
                '__set' === $method ||
                '__isset' === $method && 'id' === $parameters['name'];

            if (!$isAllowedMethod) {
                $initializer = null; // disable initialization
                // load data and modify the object here
                if ($id) {
                    $repository = $sdk->getRepository(
                        $classMetadata->getModelName()
                    );
                    $model = $repository->find($id);

                    $attributeList = $classMetadata->getAttributeList();

                    foreach ($attributeList as $attribute) {
                        $getter =
                            'get' . ucfirst($attribute->getAttributeName());
                        $value = $model->{$getter}();
                        $properties[
                            "\0" .
                            $proxyModelName .
                            "\0" .
                            $attribute->getAttributeName()
                        ] = $value;
                    }
                }

                return true; // confirm that initialization occurred correctly
            }
        };

        // initialize the proxy instance
        $instance = $factory->createProxy($modelName, $initializer, [
            'skippedProperties' => ["\0" . $proxyModelName . "\0id"],
        ]);

        // set the id of the object
        $idReflexion = new \ReflectionProperty(
            $modelName,
            $classMetadata->getIdentifierAttribute()->getAttributeName()
        );
        $idReflexion->setAccessible(true);
        $idReflexion->setValue($instance, $id);

        return $instance;
    }

    /**
     * Setter for fileCachePath
     *
     * @param string $fileCachePath
     *
     * @return SdkClient
     */
    public function setFileCachePath($fileCachePath)
    {
        $this->proxyManagerConfig = new Configuration();
        $this->proxyManagerConfig->setProxiesTargetDir($fileCachePath);

        return $this;
    }
}


1		<?php
2
3		namespace Mapado\RestClientSdk;
4
5		use Mapado\RestClientSdk\Model\ModelHydrator;
6		use Mapado\RestClientSdk\Model\Serializer;
7		use ProxyManager\Configuration;
8		use ProxyManager\Factory\LazyLoadingGhostFactory;
9		use ProxyManager\Proxy\GhostObjectInterface;
10		use Psr\Cache\CacheItemPoolInterface;
11
12		/**
13		* Sdk Client
14		*/
15		class SdkClient
16		{
17		/**
18		* @var RestClient
19		*/
20		protected $restClient;
21
22		/**
23		* Cache item pool.
24		*
25		* @var ?CacheItemPoolInterface
26		*/
27		protected $cacheItemPool;
28
29		/**
30		* Cache prefix.
31		*
32		* @var string
33		*/
34		protected $cachePrefix;
35
36		/**
37		* @var Mapping
38		*/
39		private $mapping;
40
41		/**
42		* @var Serializer
43		*/
44		private $serializer;
45
46		/**
47		* @var ModelHydrator
48		*/
49		private $modelHydrator;
50
51		/**
52		* @var array
53		*/
54		private $repositoryList = [];
55
56		/**
57		* proxyManagerConfig
58		*
59		* @var ?Configuration
60		*/
61		private $proxyManagerConfig;
62
63		/**
64		* unitOfWork
65		*
66		* @var UnitOfWork
67		*/
68		private $unitOfWork;
69
70		/**
71		* Constructor.
72		*
73		* @param RestClient $restClient
74		* @param Mapping $mapping
75		* @param UnitOfWork\|null $unitOfWork
76		* @param Serializer\|null $serializer
77		*/
78		public function __construct(
79		RestClient $restClient,
80		Mapping $mapping,
81		UnitOfWork $unitOfWork = null,
82		Serializer $serializer = null
83		) {
84	1	$this->restClient = $restClient;
85	1	$this->mapping = $mapping;
86	1	if (!$unitOfWork) {
87		$unitOfWork = new UnitOfWork($this->mapping);
88		}
89	1	$this->unitOfWork = $unitOfWork;
90	1	if (!$serializer) {
91		$serializer = new Serializer($this->mapping, $this->unitOfWork);
92		}
93	1	$this->serializer = $serializer;
94	1	$this->serializer->setSdk($this);
95
96	1	$this->modelHydrator = new ModelHydrator($this);
97	1	}
98
99		/**
100		* setCacheItemPool
101		*
102		* @param CacheItemPoolInterface $cacheItemPool
103		*
104		* @return SdkClient
105		*/
106		public function setCacheItemPool(
107		CacheItemPoolInterface $cacheItemPool,
108		$cachePrefix = ''
109		) {
110		$this->cacheItemPool = $cacheItemPool;
111		$this->cachePrefix = $cachePrefix;
112
113		return $this;
114		}
115
116		/**
117		* getCacheItemPool
118		*
119		* @return ?CacheItemPoolInterface
120		*/
121		public function getCacheItemPool()
122		{
123		return $this->cacheItemPool;
124		}
125
126		/**
127		* getCachePrefix
128		*
129		* @return string
130		*/
131		public function getCachePrefix()
132		{
133		return $this->cachePrefix;
134		}
135
136		/**
137		* getRepository
138		*
139		* @param string $modelName
140		*
141		* @return EntityRepository
142		*/
143		public function getRepository($modelName)
144		{
145		// get repository by key
146	1	$metadata = $this->mapping->getClassMetadataByKey($modelName);
147	1	if (!$metadata) {
148		// get by classname
149	1	$metadata = $this->mapping->getClassMetadata($modelName);
150		}
151
152	1	$modelName = $metadata->getModelName();
153
154	1	if (!isset($this->repositoryList[$modelName])) {
155		$repositoryName =
156	1	$metadata->getRepositoryName()
157	1	?: '\Mapado\RestClientSdk\EntityRepository';
158	1	$this->repositoryList[$modelName] = new $repositoryName(
159	1	$this,
160	1	$this->restClient,
161	1	$this->unitOfWork,
162	1	$modelName
163		);
164		}
165
166	1	return $this->repositoryList[$modelName];
167		}
168
169		/**
170		* getRestClient
171		*
172		* @return RestClient
173		*/
174		public function getRestClient()
175		{
176	1	return $this->restClient;
177		}
178
179		/**
180		* getMapping
181		*
182		* @return Mapping
183		*/
184		public function getMapping()
185		{
186	1	return $this->mapping;
187		}
188
189		/**
190		* getSerializer
191		*
192		* @return Serializer
193		*/
194		public function getSerializer()
195		{
196	1	return $this->serializer;
197		}
198
199		/**
200		* getModelHydrator
201		*
202		* @return ModelHydrator
203		*/
204		public function getModelHydrator()
205		{
206		return $this->modelHydrator;
207		}
208
209		/**
210		* createProxy
211		*
212		* @param string $id
213		*
214		* @return \ProxyManager\Proxy\GhostObjectInterface
215		*/
216		public function createProxy($id)
217		{
218		$key = $this->mapping->getKeyFromId($id);
219		$classMetadata = $this->mapping->getClassMetadataByKey($key);
220
221		if (null === $classMetadata) {
222		throw new \RuntimeException(
223		"Unable to get classMetadata for key {$key}. This should not happen."
224		);
225		}
226
227		$modelName = $classMetadata->getModelName();
228
229		$sdk = $this;
230
231		if ($this->proxyManagerConfig) {
232		$factory = new LazyLoadingGhostFactory($this->proxyManagerConfig);
233		} else {
234		$factory = new LazyLoadingGhostFactory();
235		}
236
237		$proxyModelName = preg_replace('/^\\\\*/', '', $modelName);
238
239		$initializer = function (
240		GhostObjectInterface $proxy,
241		string $method,
242		array $parameters,
243		&$initializer,
244		array $properties
245		) use ($sdk, $classMetadata, $id, $proxyModelName) {
246		$isAllowedMethod =
247		'jsonSerialize' === $method \|\|
248		'__set' === $method \|\|
249		'__isset' === $method && 'id' === $parameters['name'];
250
251		if (!$isAllowedMethod) {
252		$initializer = null; // disable initialization
253		// load data and modify the object here
254		if ($id) {
255		$repository = $sdk->getRepository(
256		$classMetadata->getModelName()
257		);
258		$model = $repository->find($id);
259
260		$attributeList = $classMetadata->getAttributeList();
261
262		foreach ($attributeList as $attribute) {
263		$getter =
264		'get' . ucfirst($attribute->getAttributeName());
265		$value = $model->{$getter}();
266		$properties[
267		"\0" .
268		$proxyModelName .
269		"\0" .
270		$attribute->getAttributeName()
271		] = $value;
272		}
273		}
274
275		return true; // confirm that initialization occurred correctly
276		}
277		};
278
279		// initialize the proxy instance
280		$instance = $factory->createProxy($modelName, $initializer, [
281		'skippedProperties' => ["\0" . $proxyModelName . "\0id"],
282		]);
283
284		// set the id of the object
285		$idReflexion = new \ReflectionProperty(
286		$modelName,
287		$classMetadata->getIdentifierAttribute()->getAttributeName()
288		);
289		$idReflexion->setAccessible(true);
290		$idReflexion->setValue($instance, $id);
291
292		return $instance;
293		}
294
295		/**
296		* Setter for fileCachePath
297		*
298		* @param string $fileCachePath
299		*
300		* @return SdkClient
301		*/
302		public function setFileCachePath($fileCachePath)
303		{
304		$this->proxyManagerConfig = new Configuration();
305		$this->proxyManagerConfig->setProxiesTargetDir($fileCachePath);
306
307		return $this;
308		}
309		}
310

mapado / rest-client-sdk

Push — master ( cc21f4...3eeaf5 )

SdkClient::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like