Contacts::upsertPipeline() - Code Metrics - Inspection of "resource updates" - flipboxfactory/craft-hubspot - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 1d947e...a9d8b7 )

by Nate

created 2018-06-27 13:59 UTC

Contacts::upsertPipeline() A

↳ Parent: Contacts

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
dl	0
loc	23
ccs	0
cts	22
cp	0
rs	9.552
c	0
b	0
f	0
cc	2
nc	2
nop	5
crap	6

<?php

/**
 * @copyright  Copyright (c) Flipbox Digital Limited
 * @license    https://flipboxfactory.com/software/hubspot/license
 * @link       https://www.flipboxfactory.com/software/hubspot/
 */

namespace flipbox\hubspot\services\resources;

use craft\base\Element;
use craft\base\ElementInterface;
use flipbox\hubspot\criteria\ContactCriteria;
use flipbox\hubspot\criteria\ResourceCriteriaInterface;
use flipbox\hubspot\connections\ConnectionInterface;
use flipbox\hubspot\fields\Resources;
use flipbox\hubspot\helpers\TransformerHelper;
use flipbox\hubspot\HubSpot;
use flipbox\hubspot\pipeline\Resource;
use flipbox\hubspot\transformers\collections\TransformerCollectionInterface;
use Flipbox\Relay\HubSpot\Builder\Resources\Contact\Create;
use Flipbox\Relay\HubSpot\Builder\Resources\Contact\Delete;
use Flipbox\Relay\HubSpot\Builder\Resources\Contact\ReadById;
use Flipbox\Relay\HubSpot\Builder\Resources\Contact\Update;
use League\Pipeline\PipelineBuilderInterface;
use Psr\SimpleCache\CacheInterface;
use yii\base\Component;

/**
 * @author Flipbox Factory <[email protected]>
 * @since 1.0.0
 */
class Contacts extends Component
{
    use traits\HubSpotIdTrait,
        traits\ElementCriteriaTrait,
        traits\TransformElementIdTrait,
        traits\SyncByElementTrait,
        traits\DeleteByElementTrait;

    /**
     * The HubSpot Resource name
     */
    const HUBSPOT_RESOURCE = 'contacts';

    /**
     * @inheritdoc
     * @return ContactCriteria
     */
    public function getCriteria(array $criteria = []): ResourceCriteriaInterface
    {
        return new ContactCriteria($criteria);
    }

    /*******************************************
     * READ / GET
     *******************************************/

    /**
     * @param string $id
     * @param ConnectionInterface $connection
     * @param CacheInterface $cache
     * @param TransformerCollectionInterface|null $transformer
     * @param mixed|null $source
     * @return mixed
     */
    public function read(
        $id,
        ConnectionInterface $connection,
        CacheInterface $cache,
        TransformerCollectionInterface $transformer = null,
        $source = null
    ) {
        return $this->readPipeline(
            $id,
            $connection,
            $cache,
            $transformer
        )($source);
    }

    /**
     * @param string $id
     * @param ConnectionInterface $connection
     * @param CacheInterface $cache
     * @param TransformerCollectionInterface|null $transformer
     * @return Resource
     */
    public function readPipeline(
        $id,
        ConnectionInterface $connection,
        CacheInterface $cache,
        TransformerCollectionInterface $transformer = null
    ): PipelineBuilderInterface {
        $transformer = TransformerHelper::populateTransformerCollection($transformer, [
            'resource' => [ReadById::class]
        ]);

        return (new Resource(
            (new ReadById(
                $id,
                $connection,
                $cache
            ))->build(),
            $transformer
        ));
    }

    /**
     * @inheritdoc
     * @return mixed
     */
    public function readByCriteria(
        ResourceCriteriaInterface $criteria,
        $source = null
    ) {
        return $this->readPipelineByCriteria(
            $criteria
        )($source);
    }

    /**
     * @param ResourceCriteriaInterface $criteria
     * @return PipelineBuilderInterface
     */
    public function readPipelineByCriteria(
        ResourceCriteriaInterface $criteria
    ): PipelineBuilderInterface {
        return $this->readPipeline(
            $criteria->getId(),
            $criteria->getConnection(),
            $criteria->getCache(),
            $criteria->getTransformer()
        );
    }

    /*******************************************
     * CREATE
     *******************************************/

    /**
     * @param array $payload
     * @param ConnectionInterface $connection
     * @param TransformerCollectionInterface|null $transformer
     * @param null $source
     * @return mixed
     */
    public function create(
        array $payload,
        ConnectionInterface $connection,
        TransformerCollectionInterface $transformer = null,
        $source = null
    ) {
        return $this->createPipeline(
            $payload,
            $connection,
            $transformer
        )($source);
    }

    /**
     * @param array $payload
     * @param ConnectionInterface $connection
     * @param TransformerCollectionInterface|null $transformer
     * @return Resource
     */
    public function createPipeline(
        array $payload,
        ConnectionInterface $connection,
        TransformerCollectionInterface $transformer = null
    ): PipelineBuilderInterface {
        $transformer = TransformerHelper::populateTransformerCollection($transformer, [
            'resource' => [Create::class]
        ]);

        return (new Resource(
            (new Create(
                $payload,
                $connection
            ))->build(),
            $transformer
        ));
    }

    /**
     * @param ResourceCriteriaInterface $criteria
     * @param mixed $source
     * @return mixed
     */
    public function createByCriteria(
        ResourceCriteriaInterface $criteria,
        $source = null
    ) {
        return $this->createPipelineByCriteria(
            $criteria
        )($source);
    }

    /**
     * @param ResourceCriteriaInterface $criteria
     * @return Resource
     */
    public function createPipelineByCriteria(
        ResourceCriteriaInterface $criteria
    ): PipelineBuilderInterface {
        return $this->createPipeline(
            $criteria->getPayload(),
            $criteria->getConnection(),
            $criteria->getTransformer()
        );
    }

    /*******************************************
     * UPDATE
     *******************************************/

    /**
     * @param string $id
     * @param array $payload
     * @param ConnectionInterface $connection
     * @param CacheInterface $cache
     * @param TransformerCollectionInterface|null $transformer
     * @param null $source
     * @return mixed
     */
    public function update(
        string $id,
        array $payload,
        ConnectionInterface $connection,
        CacheInterface $cache,
        TransformerCollectionInterface $transformer = null,
        $source = null
    ) {
        return $this->updatePipeline(
            $id,
            $payload,
            $connection,
            $cache,
            $transformer
        )($source);
    }

    /**
     * @param string $id
     * @param array $payload
     * @param ConnectionInterface $connection
     * @param CacheInterface $cache
     * @param TransformerCollectionInterface|null $transformer
     * @return Resource
     */
    public function updatePipeline(
        string $id,
        array $payload,
        ConnectionInterface $connection,
        CacheInterface $cache,
        TransformerCollectionInterface $transformer = null
    ): PipelineBuilderInterface {
        $transformer = TransformerHelper::populateTransformerCollection($transformer, [
            'resource' => [Update::class]
        ]);

        return (new Resource(
            (new Update(
                $id,
                $payload,
                $connection,
                $cache
            ))->build(),
            $transformer
        ));
    }

    /**
     * @param ResourceCriteriaInterface $criteria
     * @param null $source
     * @return mixed
     */
    public function updateByCriteria(
        ResourceCriteriaInterface $criteria,
        $source = null
    ) {
        return $this->updatePipelineByCriteria(
            $criteria
        )($source);
    }

    /**
     * @param ResourceCriteriaInterface $criteria
     * @return Resource
     */
    public function updatePipelineByCriteria(
        ResourceCriteriaInterface $criteria
    ): PipelineBuilderInterface {
        return $this->updatePipeline(
            $criteria->getId(),
            $criteria->getPayload(),
            $criteria->getConnection(),
            $criteria->getCache(),
            $criteria->getTransformer()
        );
    }

    /*******************************************
     * UPSERT
     *******************************************/

    /**
     * @param array $payload
     * @param ConnectionInterface $connection
     * @param CacheInterface $cache
     * @param string|null $identifier
     * @param TransformerCollectionInterface|null $transformer
     * @param null $source
     * @return mixed
     */
    public function upsert(
        array $payload,
        ConnectionInterface $connection,
        CacheInterface $cache,
        string $identifier = null,
        TransformerCollectionInterface $transformer = null,
        $source = null
    ) {
        return $this->upsertPipeline(
            $payload,
            $connection,
            $cache,
            $identifier,
            $transformer
        )($source);
    }

    /**
     * @param array $payload
     * @param ConnectionInterface $connection
     * @param CacheInterface $cache
     * @param string|null $identifier
     * @param TransformerCollectionInterface|null $transformer
     * @return Resource
     */
    public function upsertPipeline(
        array $payload,
        ConnectionInterface $connection,
        CacheInterface $cache,
        string $identifier = null,
        TransformerCollectionInterface $transformer = null
    ): PipelineBuilderInterface {
        if (empty($identifier)) {
            return $this->create(
                $payload,
                $connection,
                $transformer
            );
        }

        return $this->update(
            $identifier,
            $payload,
            $connection,
            $cache,
            $transformer
        );
    }

    /**
     * @inheritdoc
     * @return mixed
     */
    public function upsertByCriteria(
        ResourceCriteriaInterface $criteria,
        $source = null
    ): PipelineBuilderInterface {
        return $this->upsertPipelineByCriteria(
            $criteria
        )($source);
    }

    /**
     * @inheritdoc
     * @return Resource
     */
    public function upsertPipelineByCriteria(
        ResourceCriteriaInterface $criteria
    ): PipelineBuilderInterface {
        return $this->upsert(
            $criteria->getPayload(),
            $criteria->getConnection(),
            $criteria->getCache(),
            $criteria->getId(),
            $criteria->getTransformer()
        );
    }


    /*******************************************
     * DELETE
     *******************************************/

    /**
     * @param string $id
     * @param ConnectionInterface $connection
     * @param CacheInterface $cache
     * @param TransformerCollectionInterface|null $transformer
     * @param null $source
     * @return mixed
     */
    public function delete(
        string $id,
        ConnectionInterface $connection,
        CacheInterface $cache,
        TransformerCollectionInterface $transformer = null,
        $source = null
    ): PipelineBuilderInterface {
        return $this->deletePipeline(
            $id,
            $connection,
            $cache,
            $transformer
        )($source);
    }

    /**
     * @param string $id
     * @param ConnectionInterface $connection
     * @param CacheInterface $cache
     * @param TransformerCollectionInterface|null $transformer
     * @return Resource
     */
    public function deletePipeline(
        string $id,
        ConnectionInterface $connection,
        CacheInterface $cache,
        TransformerCollectionInterface $transformer = null
    ): PipelineBuilderInterface {
        $transformer = TransformerHelper::populateTransformerCollection($transformer, [
            'resource' => [Delete::class]
        ]);

        return (new Resource(
            (new Delete(
                $id,
                $connection,
                $cache
            ))->build(),
            $transformer
        ));
    }

    /**
     * @param ResourceCriteriaInterface $criteria
     * @param null $source
     * @return mixed
     */
    public function deleteByCriteria(
        ResourceCriteriaInterface $criteria,
        $source = null
    ): PipelineBuilderInterface {
        return $this->deletePipelineByCriteria(
            $criteria
        )($source);
    }

    /**
     * @param ResourceCriteriaInterface $criteria
     * @return Resource
     */
    public function deletePipelineByCriteria(
        ResourceCriteriaInterface $criteria
    ): PipelineBuilderInterface {
        return $this->delete(
            $criteria->getId(),
            $criteria->getConnection(),
            $criteria->getCache(),
            $criteria->getTransformer()
        );
    }
}


1			<?php
2
3			/**
4			* @copyright Copyright (c) Flipbox Digital Limited
5			* @license https://flipboxfactory.com/software/hubspot/license
6			* @link https://www.flipboxfactory.com/software/hubspot/
7			*/
8
9			namespace flipbox\hubspot\services\resources;
10
11			use craft\base\Element;
12			use craft\base\ElementInterface;
13			use flipbox\hubspot\criteria\ContactCriteria;
14			use flipbox\hubspot\criteria\ResourceCriteriaInterface;
15			use flipbox\hubspot\connections\ConnectionInterface;
16			use flipbox\hubspot\fields\Resources;
17			use flipbox\hubspot\helpers\TransformerHelper;
18			use flipbox\hubspot\HubSpot;
19			use flipbox\hubspot\pipeline\Resource;
20			use flipbox\hubspot\transformers\collections\TransformerCollectionInterface;
21			use Flipbox\Relay\HubSpot\Builder\Resources\Contact\Create;
22			use Flipbox\Relay\HubSpot\Builder\Resources\Contact\Delete;
23			use Flipbox\Relay\HubSpot\Builder\Resources\Contact\ReadById;
24			use Flipbox\Relay\HubSpot\Builder\Resources\Contact\Update;
25			use League\Pipeline\PipelineBuilderInterface;
26			use Psr\SimpleCache\CacheInterface;
27			use yii\base\Component;
28
29			/**
30			* @author Flipbox Factory <[email protected]>
31			* @since 1.0.0
32			*/
33			class Contacts extends Component
34			{
35			use traits\HubSpotIdTrait,
36			traits\ElementCriteriaTrait,
37			traits\TransformElementIdTrait,
38			traits\SyncByElementTrait,
39			traits\DeleteByElementTrait;
40
41			/**
42			* The HubSpot Resource name
43			*/
44			const HUBSPOT_RESOURCE = 'contacts';
45
46			/**
47			* @inheritdoc
48			* @return ContactCriteria
49			*/
50			public function getCriteria(array $criteria = []): ResourceCriteriaInterface
51			{
52			return new ContactCriteria($criteria);
53			}
54
55			/*******************************************
56			* READ / GET
57			*******************************************/
58
59			/**
60			* @param string $id
61			* @param ConnectionInterface $connection
62			* @param CacheInterface $cache
63			* @param TransformerCollectionInterface\|null $transformer
64			* @param mixed\|null $source
65			* @return mixed
66			*/
67			public function read(
68			$id,
69			ConnectionInterface $connection,
70			CacheInterface $cache,
71			TransformerCollectionInterface $transformer = null,
72			$source = null
73			) {
74			return $this->readPipeline(
75			$id,
76			$connection,
77			$cache,
78			$transformer
79			)($source);
80			}
81
82			/**
83			* @param string $id
84			* @param ConnectionInterface $connection
85			* @param CacheInterface $cache
86			* @param TransformerCollectionInterface\|null $transformer
87			* @return Resource
88			*/
89			public function readPipeline(
90			$id,
91			ConnectionInterface $connection,
92			CacheInterface $cache,
93			TransformerCollectionInterface $transformer = null
94			): PipelineBuilderInterface {
95			$transformer = TransformerHelper::populateTransformerCollection($transformer, [
96			'resource' => [ReadById::class]
97			]);
98
99			return (new Resource(
100			(new ReadById(
101			$id,
102			$connection,
103			$cache
104			))->build(),
105			$transformer
106			));
107			}
108
109			/**
110			* @inheritdoc
111			* @return mixed
112			*/
113			public function readByCriteria(
114			ResourceCriteriaInterface $criteria,
115			$source = null
116			) {
117			return $this->readPipelineByCriteria(
118			$criteria
119			)($source);
120			}
121
122			/**
123			* @param ResourceCriteriaInterface $criteria
124			* @return PipelineBuilderInterface
125			*/
126			public function readPipelineByCriteria(
127			ResourceCriteriaInterface $criteria
128			): PipelineBuilderInterface {
129			return $this->readPipeline(
130			$criteria->getId(),
131			$criteria->getConnection(),
132			$criteria->getCache(),
133			$criteria->getTransformer()
134			);
135			}
136
137			/*******************************************
138			* CREATE
139			*******************************************/
140
141			/**
142			* @param array $payload
143			* @param ConnectionInterface $connection
144			* @param TransformerCollectionInterface\|null $transformer
145			* @param null $source
146			* @return mixed
147			*/
148			public function create(
149			array $payload,
150			ConnectionInterface $connection,
151			TransformerCollectionInterface $transformer = null,
152			$source = null
153			) {
154			return $this->createPipeline(
155			$payload,
156			$connection,
157			$transformer
158			)($source);
159			}
160
161			/**
162			* @param array $payload
163			* @param ConnectionInterface $connection
164			* @param TransformerCollectionInterface\|null $transformer
165			* @return Resource
166			*/
167			public function createPipeline(
168			array $payload,
169			ConnectionInterface $connection,
170			TransformerCollectionInterface $transformer = null
171			): PipelineBuilderInterface {
172			$transformer = TransformerHelper::populateTransformerCollection($transformer, [
173			'resource' => [Create::class]
174			]);
175
176			return (new Resource(
177			(new Create(
178			$payload,
179			$connection
180			))->build(),
181			$transformer
182			));
183			}
184
185			/**
186			* @param ResourceCriteriaInterface $criteria
187			* @param mixed $source
188			* @return mixed
189			*/
190			public function createByCriteria(
191			ResourceCriteriaInterface $criteria,
192			$source = null
193			) {
194			return $this->createPipelineByCriteria(
195			$criteria
196			)($source);
197			}
198
199			/**
200			* @param ResourceCriteriaInterface $criteria
201			* @return Resource
202			*/
203			public function createPipelineByCriteria(
204			ResourceCriteriaInterface $criteria
205			): PipelineBuilderInterface {
206			return $this->createPipeline(
207			$criteria->getPayload(),
208			$criteria->getConnection(),
209			$criteria->getTransformer()
210			);
211			}
212
213			/*******************************************
214			* UPDATE
215			*******************************************/
216
217			/**
218			* @param string $id
219			* @param array $payload
220			* @param ConnectionInterface $connection
221			* @param CacheInterface $cache
222			* @param TransformerCollectionInterface\|null $transformer
223			* @param null $source
224			* @return mixed
225			*/
226			public function update(
227			string $id,
228			array $payload,
229			ConnectionInterface $connection,
230			CacheInterface $cache,
231			TransformerCollectionInterface $transformer = null,
232			$source = null
233			) {
234			return $this->updatePipeline(
235			$id,
236			$payload,
237			$connection,
238			$cache,
239			$transformer
240			)($source);
241			}
242
243			/**
244			* @param string $id
245			* @param array $payload
246			* @param ConnectionInterface $connection
247			* @param CacheInterface $cache
248			* @param TransformerCollectionInterface\|null $transformer
249			* @return Resource
250			*/
251			public function updatePipeline(
252			string $id,
253			array $payload,
254			ConnectionInterface $connection,
255			CacheInterface $cache,
256			TransformerCollectionInterface $transformer = null
257			): PipelineBuilderInterface {
258			$transformer = TransformerHelper::populateTransformerCollection($transformer, [
259			'resource' => [Update::class]
260			]);
261
262			return (new Resource(
263			(new Update(
264			$id,
265			$payload,
266			$connection,
267			$cache
268			))->build(),
269			$transformer
270			));
271			}
272
273			/**
274			* @param ResourceCriteriaInterface $criteria
275			* @param null $source
276			* @return mixed
277			*/
278			public function updateByCriteria(
279			ResourceCriteriaInterface $criteria,
280			$source = null
281			) {
282			return $this->updatePipelineByCriteria(
283			$criteria
284			)($source);
285			}
286
287			/**
288			* @param ResourceCriteriaInterface $criteria
289			* @return Resource
290			*/
291			public function updatePipelineByCriteria(
292			ResourceCriteriaInterface $criteria
293			): PipelineBuilderInterface {
294			return $this->updatePipeline(
295			$criteria->getId(),
296			$criteria->getPayload(),
297			$criteria->getConnection(),
298			$criteria->getCache(),
299			$criteria->getTransformer()
300			);
301			}
302
303			/*******************************************
304			* UPSERT
305			*******************************************/
306
307			/**
308			* @param array $payload
309			* @param ConnectionInterface $connection
310			* @param CacheInterface $cache
311			* @param string\|null $identifier
312			* @param TransformerCollectionInterface\|null $transformer
313			* @param null $source
314			* @return mixed
315			*/
316			public function upsert(
317			array $payload,
318			ConnectionInterface $connection,
319			CacheInterface $cache,
320			string $identifier = null,
321			TransformerCollectionInterface $transformer = null,
322			$source = null
323			) {
324			return $this->upsertPipeline(
325			$payload,
326			$connection,
327			$cache,
328			$identifier,
329			$transformer
330			)($source);
331			}
332
333			/**
334			* @param array $payload
335			* @param ConnectionInterface $connection
336			* @param CacheInterface $cache
337			* @param string\|null $identifier
338			* @param TransformerCollectionInterface\|null $transformer
339			* @return Resource
340			*/
341			public function upsertPipeline(
342			array $payload,
343			ConnectionInterface $connection,
344			CacheInterface $cache,
345			string $identifier = null,
346			TransformerCollectionInterface $transformer = null
347			): PipelineBuilderInterface {
348			if (empty($identifier)) {
349			return $this->create(
350			$payload,
351			$connection,
352			$transformer
353			);
354			}
355
356			return $this->update(
357			$identifier,
358			$payload,
359			$connection,
360			$cache,
361			$transformer
362			);
363			}
364
365			/**
366			* @inheritdoc
367			* @return mixed
368			*/
369			public function upsertByCriteria(
370			ResourceCriteriaInterface $criteria,
371			$source = null
372			): PipelineBuilderInterface {
373			return $this->upsertPipelineByCriteria(
374			$criteria
375			)($source);
376			}
377
378			/**
379			* @inheritdoc
380			* @return Resource
381			*/
382			public function upsertPipelineByCriteria(
383			ResourceCriteriaInterface $criteria
384			): PipelineBuilderInterface {
385			return $this->upsert(
386			$criteria->getPayload(),
387			$criteria->getConnection(),
388			$criteria->getCache(),
389			$criteria->getId(),
390			$criteria->getTransformer()
391			);
392			}
393
394
395			/*******************************************
396			* DELETE
397			*******************************************/
398
399			/**
400			* @param string $id
401			* @param ConnectionInterface $connection
402			* @param CacheInterface $cache
403			* @param TransformerCollectionInterface\|null $transformer
404			* @param null $source
405			* @return mixed
406			*/
407			public function delete(
408			string $id,
409			ConnectionInterface $connection,
410			CacheInterface $cache,
411			TransformerCollectionInterface $transformer = null,
412			$source = null
413			): PipelineBuilderInterface {
414			return $this->deletePipeline(
415			$id,
416			$connection,
417			$cache,
418			$transformer
419			)($source);
420			}
421
422			/**
423			* @param string $id
424			* @param ConnectionInterface $connection
425			* @param CacheInterface $cache
426			* @param TransformerCollectionInterface\|null $transformer
427			* @return Resource
428			*/
429			public function deletePipeline(
430			string $id,
431			ConnectionInterface $connection,
432			CacheInterface $cache,
433			TransformerCollectionInterface $transformer = null
434			): PipelineBuilderInterface {
435			$transformer = TransformerHelper::populateTransformerCollection($transformer, [
436			'resource' => [Delete::class]
437			]);
438
439			return (new Resource(
440			(new Delete(
441			$id,
442			$connection,
443			$cache
444			))->build(),
445			$transformer
446			));
447			}
448
449			/**
450			* @param ResourceCriteriaInterface $criteria
451			* @param null $source
452			* @return mixed
453			*/
454			public function deleteByCriteria(
455			ResourceCriteriaInterface $criteria,
456			$source = null
457			): PipelineBuilderInterface {
458			return $this->deletePipelineByCriteria(
459			$criteria
460			)($source);
461			}
462
463			/**
464			* @param ResourceCriteriaInterface $criteria
465			* @return Resource
466			*/
467			public function deletePipelineByCriteria(
468			ResourceCriteriaInterface $criteria
469			): PipelineBuilderInterface {
470			return $this->delete(
471			$criteria->getId(),
472			$criteria->getConnection(),
473			$criteria->getCache(),
474			$criteria->getTransformer()
475			);
476			}
477			}
478

flipboxfactory / craft-hubspot

Push — develop ( 1d947e...a9d8b7 )

Contacts::upsertPipeline() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like