Companies::delete() - 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

Companies::delete() A

↳ Parent: Companies

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	14
ccs	0
cts	14
cp	0
rs	9.7998
c	0
b	0
f	0
cc	1
nc	1
nop	5
crap	2

<?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\connections\ConnectionInterface;
use flipbox\hubspot\criteria\CompanyCriteria;
use flipbox\hubspot\criteria\ResourceCriteriaInterface;
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\Company\Create;
use Flipbox\Relay\HubSpot\Builder\Resources\Company\Delete;
use Flipbox\Relay\HubSpot\Builder\Resources\Company\Read;
use Flipbox\Relay\HubSpot\Builder\Resources\Company\Update;
use League\Pipeline\PipelineBuilderInterface;
use Psr\SimpleCache\CacheInterface;
use yii\base\Component;


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

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

    /**
     * @inheritdoc
     * @return CompanyCriteria
     */
    public function getCriteria(array $criteria = []): ResourceCriteriaInterface
    {
        return new CompanyCriteria($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' => [Read::class]
        ]);

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

flipboxfactory / craft-hubspot

Push — develop ( 1d947e...a9d8b7 )

Companies::delete() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like