Manager::addTargets() - Code Metrics - Inspection of "Enable multiple targets from the same type (#27)" - sirdiego/importr - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3559e6...f42a1c )

by diego

created 2021-05-20 12:14 UTC

Manager::addTargets() A

↳ Parent: Manager

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
dl	0
loc	15
ccs	0
cts	11
cp	0
rs	9.7666
c	0
b	0
f	0
cc	3
nc	3
nop	3
crap	12

<?php

declare(strict_types=1);

namespace HDNET\Importr\Service;

use HDNET\Importr\Domain\Model\Import;
use HDNET\Importr\Domain\Model\Strategy;
use HDNET\Importr\Domain\Repository\ImportRepository;
use HDNET\Importr\Exception\ReinitializeException;
use HDNET\Importr\Processor\Configuration;
use HDNET\Importr\Processor\Resource;
use TYPO3\CMS\Extbase\Object\ObjectManager;
use TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager;
use TYPO3\CMS\Extbase\SignalSlot\Dispatcher;

/**
 * Service Manager
 *
 * @license http://www.gnu.org/licenses/gpl.html GNU General Public License, version 3 or later
 * @author  Tim Lochmüller <[email protected]>
 */
class Manager implements ManagerInterface
{

    /**
     * @var \HDNET\Importr\Domain\Repository\ImportRepository
     */
    protected $importRepository;

    /**
     * @var \TYPO3\CMS\Extbase\SignalSlot\Dispatcher
     */
    protected $signalSlotDispatcher;

    /**
     * @var \TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager
     */
    protected $persistenceManager;

    /**
     * @var \TYPO3\CMS\Extbase\Object\ObjectManager
     */
    protected $objectManager;

    /**
     * @var \HDNET\Importr\Processor\Configuration
     */
    protected $configuration;

    /**
     * @var \HDNET\Importr\Processor\Resource
     */
    protected $resource;

    public function __construct(
        ImportRepository $importRepository,
        Dispatcher $signalSlotDispatcher,
        PersistenceManager $persistenceManager,
        ObjectManager $objectManager,
        Configuration $configuration,
        Resource $resource
    ) {
        $this->importRepository = $importRepository;
        $this->signalSlotDispatcher = $signalSlotDispatcher;
        $this->persistenceManager = $persistenceManager;
        $this->objectManager = $objectManager;
        $this->configuration = $configuration;
        $this->resource = $resource;
    }

    /**
     * Update Interval
     *
     * @var int
     */
    protected $updateInterval = 1;

    /**
     * run the Importr
     */
    public function runImports()
    {
        try {
            $imports = $this->importRepository->findWorkQueue();
            foreach ($imports as $import) {
                $this->runImport($import);
            }
        } catch (ReinitializeException $exc) {
            $this->runImports();
        }
    }

    /**
     * Get the preview
     *
     * @param string                               $filepath
     * @param \HDNET\Importr\Domain\Model\Strategy $strategy
     *
     * @return array
     */
    public function getPreview(Strategy $strategy, $filepath)
    {
        $data = [];
        $resources = $this->initializeResources($strategy, $filepath);
        foreach ($resources as $resource) {
            /** @var \HDNET\Importr\Service\Resources\ResourceInterface $resource */
            // Resourcen Object anhand der Datei auswählen
            if (\preg_match($resource->getFilepathExpression(), $filepath)) {
                // Resource "benutzen"
                $resource->parseResource();
                // Durchlauf starten
                for ($pointer = 0; $pointer <= 20; $pointer++) {
                    if ($resource->getEntry($pointer)) {
                        $data[] = $resource->getEntry($pointer);
                    }
                }
                break;
            }
        }
        return $data;
    }

    /**
     * Magic Runner
     *
     * @param \HDNET\Importr\Domain\Model\Import $import
     */
    protected function runImport(Import $import)
    {
        $this->emitSignal('preImport', $import);

        $resources = $this->initializeResourcesByImport($import);
        $targets = $this->initializeTargets($import);
        $strategyConfiguration = $import->getStrategy()
            ->getConfiguration();

        foreach ($resources as $resource) {
            if ($this->resource->process($import, $targets, $strategyConfiguration, $resource, $this)) {
                break;
            }
        }

        $this->teardownTargets($import);

        $this->emitSignal('postImport', $import);
    }

    /**
     * @param \HDNET\Importr\Domain\Model\Import $import
     *
     * @return array
     */
    protected function initializeResourcesByImport(Import $import)
    {
        return $this->initializeResources($import->getStrategy(), $import->getFilepath());
    }

    /**
     * @param \HDNET\Importr\Domain\Model\Strategy $strategy
     * @param string                               $filepath
     *
     * @return array
     */
    protected function initializeResources(Strategy $strategy, $filepath)
    {
        $resources = [];
        $resourceConfiguration = $strategy->getResources();
        foreach ($resourceConfiguration as $resource => $configuration) {
            $object = $this->objectManager->get($resource);

            $object->start($strategy, $filepath);
            $object->setConfiguration($configuration);
            $resources[$resource] = $object;
        }
        return $resources;
    }

    /**
     * @param \HDNET\Importr\Domain\Model\Import $import
     *
     * @return array
     */
    protected function initializeTargets(Import $import)
    {
        $targetConfiguration = $import->getStrategy()
            ->getTargets();
        return $this->addTargets($targetConfiguration, $import);
    }

    protected function addTargets(array $targetConfiguration, Import $import, array $targets = []): array
    {
        foreach ($targetConfiguration as $target => $configuration) {
            if (\is_numeric($target)) {
                $targets = $this->addTargets($configuration, $import, $targets);
                continue;
            }
            $object = $this->objectManager->get($target);

            $object->setConfiguration($configuration);
            $object->getConfiguration();
            $object->start($import->getStrategy());
            $targets[] = $object;
        }
        return $targets;
    }

    /**
     * @param \HDNET\Importr\Domain\Model\Import $import
     */
    protected function teardownTargets(Import $import)
    {
        $targetConfiguration = $import->getStrategy()
            ->getTargets();
        $this->endTargets($targetConfiguration, $import);
    }

    protected function endTargets(array $targetConfiguration, Import $import): void
    {
        foreach ($targetConfiguration as $target => $configuration) {
            if (\is_numeric($target)) {
                $this->endTargets($configuration, $import);
                continue;
            }
            $object = $this->objectManager->get($target);

            $object->setConfiguration($configuration);
            $object->getConfiguration();
            $object->end($import->getStrategy());
        }
    }

    /**
     * @param int $interval
     */
    public function setUpdateInterval($interval)
    {
        $this->updateInterval = $interval;
    }

    /**
     * @return int
     */
    public function getUpdateInterval()
    {
        return $this->updateInterval;
    }

    /**
     * @param string $name
     * @param Import $import
     */
    protected function emitSignal($name, Import $import)
    {
        $this->signalSlotDispatcher->dispatch(
            __CLASS__,
            $name,
            [$this, $import]
        );
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace HDNET\Importr\Service;
6
7			use HDNET\Importr\Domain\Model\Import;
8			use HDNET\Importr\Domain\Model\Strategy;
9			use HDNET\Importr\Domain\Repository\ImportRepository;
10			use HDNET\Importr\Exception\ReinitializeException;
11			use HDNET\Importr\Processor\Configuration;
12			use HDNET\Importr\Processor\Resource;
13			use TYPO3\CMS\Extbase\Object\ObjectManager;
14			use TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager;
15			use TYPO3\CMS\Extbase\SignalSlot\Dispatcher;
16
17			/**
18			* Service Manager
19			*
20			* @license http://www.gnu.org/licenses/gpl.html GNU General Public License, version 3 or later
21			* @author Tim Lochmüller <[email protected]>
22			*/
23			class Manager implements ManagerInterface
24			{
25
26			/**
27			* @var \HDNET\Importr\Domain\Repository\ImportRepository
28			*/
29			protected $importRepository;
30
31			/**
32			* @var \TYPO3\CMS\Extbase\SignalSlot\Dispatcher
33			*/
34			protected $signalSlotDispatcher;
35
36			/**
37			* @var \TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager
38			*/
39			protected $persistenceManager;
40
41			/**
42			* @var \TYPO3\CMS\Extbase\Object\ObjectManager
43			*/
44			protected $objectManager;
45
46			/**
47			* @var \HDNET\Importr\Processor\Configuration
48			*/
49			protected $configuration;
50
51			/**
52			* @var \HDNET\Importr\Processor\Resource
53			*/
54			protected $resource;
55
56			public function __construct(
57			ImportRepository $importRepository,
58			Dispatcher $signalSlotDispatcher,
59			PersistenceManager $persistenceManager,
60			ObjectManager $objectManager,
61			Configuration $configuration,
62			Resource $resource
63			) {
64			$this->importRepository = $importRepository;
65			$this->signalSlotDispatcher = $signalSlotDispatcher;
66			$this->persistenceManager = $persistenceManager;
67			$this->objectManager = $objectManager;
68			$this->configuration = $configuration;
69			$this->resource = $resource;
70			}
71
72			/**
73			* Update Interval
74			*
75			* @var int
76			*/
77			protected $updateInterval = 1;
78
79			/**
80			* run the Importr
81			*/
82			public function runImports()
83			{
84			try {
85			$imports = $this->importRepository->findWorkQueue();
86			foreach ($imports as $import) {
87			$this->runImport($import);
88			}
89			} catch (ReinitializeException $exc) {
90			$this->runImports();
91			}
92			}
93
94			/**
95			* Get the preview
96			*
97			* @param string $filepath
98			* @param \HDNET\Importr\Domain\Model\Strategy $strategy
99			*
100			* @return array
101			*/
102			public function getPreview(Strategy $strategy, $filepath)
103			{
104			$data = [];
105			$resources = $this->initializeResources($strategy, $filepath);
106			foreach ($resources as $resource) {
107			/** @var \HDNET\Importr\Service\Resources\ResourceInterface $resource */
108			// Resourcen Object anhand der Datei auswählen
109			if (\preg_match($resource->getFilepathExpression(), $filepath)) {
110			// Resource "benutzen"
111			$resource->parseResource();
112			// Durchlauf starten
113			for ($pointer = 0; $pointer <= 20; $pointer++) {
114			if ($resource->getEntry($pointer)) {
115			$data[] = $resource->getEntry($pointer);
116			}
117			}
118			break;
119			}
120			}
121			return $data;
122			}
123
124			/**
125			* Magic Runner
126			*
127			* @param \HDNET\Importr\Domain\Model\Import $import
128			*/
129			protected function runImport(Import $import)
130			{
131			$this->emitSignal('preImport', $import);
132
133			$resources = $this->initializeResourcesByImport($import);
134			$targets = $this->initializeTargets($import);
135			$strategyConfiguration = $import->getStrategy()
136			->getConfiguration();
137
138			foreach ($resources as $resource) {
139			if ($this->resource->process($import, $targets, $strategyConfiguration, $resource, $this)) {
140			break;
141			}
142			}
143
144			$this->teardownTargets($import);
145
146			$this->emitSignal('postImport', $import);
147			}
148
149			/**
150			* @param \HDNET\Importr\Domain\Model\Import $import
151			*
152			* @return array
153			*/
154			protected function initializeResourcesByImport(Import $import)
155			{
156			return $this->initializeResources($import->getStrategy(), $import->getFilepath());
157			}
158
159			/**
160			* @param \HDNET\Importr\Domain\Model\Strategy $strategy
161			* @param string $filepath
162			*
163			* @return array
164			*/
165			protected function initializeResources(Strategy $strategy, $filepath)
166			{
167			$resources = [];
168			$resourceConfiguration = $strategy->getResources();
169			foreach ($resourceConfiguration as $resource => $configuration) {
170			$object = $this->objectManager->get($resource);
			0 ignored issues – show Deprecated Code introduced 2020-05-12 08:33 UTC by Report Bug Copy Issue Report The method `TYPO3\CMS\Extbase\Object\ObjectManager::get()` has been deprecated with message: since TYPO3 10.4, will be removed in version 12.0 This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
171			$object->start($strategy, $filepath);
172			$object->setConfiguration($configuration);
173			$resources[$resource] = $object;
174			}
175			return $resources;
176			}
177
178			/**
179			* @param \HDNET\Importr\Domain\Model\Import $import
180			*
181			* @return array
182			*/
183			protected function initializeTargets(Import $import)
184			{
185			$targetConfiguration = $import->getStrategy()
186			->getTargets();
187			return $this->addTargets($targetConfiguration, $import);
188			}
189
190			protected function addTargets(array $targetConfiguration, Import $import, array $targets = []): array
191			{
192			foreach ($targetConfiguration as $target => $configuration) {
193			if (\is_numeric($target)) {
194			$targets = $this->addTargets($configuration, $import, $targets);
195			continue;
196			}
197			$object = $this->objectManager->get($target);
			0 ignored issues – show Deprecated Code introduced 2020-05-12 08:33 UTC by Report Bug Copy Issue Report The method `TYPO3\CMS\Extbase\Object\ObjectManager::get()` has been deprecated with message: since TYPO3 10.4, will be removed in version 12.0 This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
198			$object->setConfiguration($configuration);
199			$object->getConfiguration();
200			$object->start($import->getStrategy());
201			$targets[] = $object;
202			}
203			return $targets;
204			}
205
206			/**
207			* @param \HDNET\Importr\Domain\Model\Import $import
208			*/
209			protected function teardownTargets(Import $import)
210			{
211			$targetConfiguration = $import->getStrategy()
212			->getTargets();
213			$this->endTargets($targetConfiguration, $import);
214			}
215
216			protected function endTargets(array $targetConfiguration, Import $import): void
217			{
218			foreach ($targetConfiguration as $target => $configuration) {
219			if (\is_numeric($target)) {
220			$this->endTargets($configuration, $import);
221			continue;
222			}
223			$object = $this->objectManager->get($target);
			0 ignored issues – show Deprecated Code introduced 2020-10-24 07:00 UTC by Report Bug Copy Issue Report The method `TYPO3\CMS\Extbase\Object\ObjectManager::get()` has been deprecated with message: since TYPO3 10.4, will be removed in version 12.0 This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
224			$object->setConfiguration($configuration);
225			$object->getConfiguration();
226			$object->end($import->getStrategy());
227			}
228			}
229
230			/**
231			* @param int $interval
232			*/
233			public function setUpdateInterval($interval)
234			{
235			$this->updateInterval = $interval;
236			}
237
238			/**
239			* @return int
240			*/
241			public function getUpdateInterval()
242			{
243			return $this->updateInterval;
244			}
245
246			/**
247			* @param string $name
248			* @param Import $import
249			*/
250			protected function emitSignal($name, Import $import)
251			{
252			$this->signalSlotDispatcher->dispatch(
253			__CLASS__,
254			$name,
255			[$this, $import]
256			);
257			}
258			}
259

sirdiego / importr

Push — master ( 3559e6...f42a1c )

Manager::addTargets() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like