ImportFactory::createImportJob() - Code Metrics - treehouselabs/io-bundle - Measure and Improve Code Quality continuously with Scrutinizer

ImportFactory::createImportJob() A
last analyzed 2020-05-04 12:22 UTC

↳ Parent: ImportFactory

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	13
ccs	9
cts	9
cp	1
rs	9.8333
c	0
b	0
f	0
cc	2
nc	2
nop	2
crap	2

<?php

namespace TreeHouse\IoBundle\Import;

use Doctrine\Common\Persistence\ManagerRegistry;
use Symfony\Component\EventDispatcher\Event;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use TreeHouse\Feeder\Exception\ReadException;
use TreeHouse\Feeder\Feed;
use TreeHouse\Feeder\FeedEvents;
use TreeHouse\Feeder\Reader\ReaderInterface;
use TreeHouse\IoBundle\Entity\Feed as FeedEntity;
use TreeHouse\IoBundle\Entity\Import;
use TreeHouse\IoBundle\Entity\ImportPart;
use TreeHouse\IoBundle\Entity\ImportRepository;
use TreeHouse\IoBundle\Exception\UnfinishedImportException;
use TreeHouse\IoBundle\Import\Event\ExceptionEvent;
use TreeHouse\IoBundle\Import\Event\PartEvent;
use TreeHouse\IoBundle\Import\Feed\FeedBuilder;
use TreeHouse\IoBundle\Import\Feed\TransportFactory;
use TreeHouse\IoBundle\Import\Handler\HandlerInterface;
use TreeHouse\IoBundle\Import\Importer\Importer;
use TreeHouse\IoBundle\Import\Importer\ImporterBuilderFactory;
use TreeHouse\IoBundle\Import\Log\ItemLoggerInterface;
use TreeHouse\IoBundle\Import\Processor\ProcessorInterface;
use TreeHouse\IoBundle\Import\Reader\ReaderBuilderFactory;
use TreeHouse\IoBundle\Import\Reader\ReaderBuilderInterface;

class ImportFactory implements EventSubscriberInterface
{
    /**
     * @var ManagerRegistry
     */
    protected $doctrine;

    /**
     * @var ImportRegistry
     */
    protected $importRegistry;

    /**
     * @var ImporterBuilderFactory
     */
    protected $importerBuilderFactory;

    /**
     * @var ReaderBuilderFactory
     */
    protected $readerBuilderFactory;

    /**
     * @var ImportStorage
     */
    protected $importStorage;

    /**
     * @var EventDispatcherInterface
     */
    protected $eventDispatcher;

    /**
     * @param ManagerRegistry          $doctrine
     * @param ImportRegistry           $importRegistry
     * @param ImporterBuilderFactory   $importerBuilderFactory
     * @param ReaderBuilderFactory     $readerBuilderFactory
     * @param ImportStorage            $importStorage
     * @param EventDispatcherInterface $dispatcher
     */
    public function __construct(
        ManagerRegistry $doctrine,
        ImportRegistry $importRegistry,
        ImporterBuilderFactory $importerBuilderFactory,
        ReaderBuilderFactory $readerBuilderFactory,
        ImportStorage $importStorage,
        EventDispatcherInterface $dispatcher
    ) {
        $this->doctrine = $doctrine;
        $this->importRegistry = $importRegistry;
        $this->importerBuilderFactory = $importerBuilderFactory;
        $this->readerBuilderFactory = $readerBuilderFactory;
        $this->importStorage = $importStorage;
        $this->eventDispatcher = $dispatcher;
    }

    /**
     * @return EventDispatcherInterface
     */
    public function getEventDispatcher()
    {
        return $this->eventDispatcher;
    }

    /**
     * @inheritdoc
     */
    public static function getSubscribedEvents()
    {
        $events = [];

        foreach ([FeedEvents::class, ImportEvents::class] as $class) {
            $refl = new \ReflectionClass($class);
            foreach ($refl->getConstants() as $constant) {
                $events[$constant][] = 'relayEvent';
            }
        }

        $events[ImportEvents::EXCEPTION][] = 'onException';

        return $events;
    }

    /**
     * Relays an event to the main dispatcher in the manager.
     * This is done so listeners can subscribe to this class,
     * while each importer starts with a new dispatcher.
     
     * @param Event  $event
     * @param string $name
     */
    public function relayEvent(Event $event, $name)
    {
        $this->eventDispatcher->dispatch($name, $event);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Handler for an exception event. Importer types can listen to the same
     * event and stop propagation if they want to change this behaviour.
     *
     * @param ExceptionEvent $event
     *
     * @throws \RuntimeException
     */
    public function onException(ExceptionEvent $event)
    {
        $exception = $event->getException();
        if ($exception instanceof ReadException) {
            $msg = sprintf('Error reading feed: %s', $exception->getMessage());
        } else {
            $msg = sprintf(
                'Import aborted with %s: "%s" Stack trace: %s',
                get_class($exception),
                $exception->getMessage(),
                $exception->getTraceAsString()
            );
        }

        throw new \RuntimeException($msg, 0, $exception);
    }

    /**
     * @param ItemLoggerInterface $logger
     */
    public function setItemLogger(ItemLoggerInterface $logger)
    {
        $this->eventDispatcher->addSubscriber($logger);
    }

    /**
     * Creates an import for a feed. If an import for this feed was created
     * before, but has not started yet, that import is returned. All other open
     * imports are closed first.
     *
     * @param FeedEntity $feed         The feed to create the import for
     * @param \DateTime  $scheduleDate The date this import should start
     * @param bool       $forced       Whether to handle items that would normally be skipped
     * @param bool       $partial      If left out, it will be determined based on feed
     *
     * @throws UnfinishedImportException When an existing (and running) import is found
     *
     * @return Import
     */
    public function createImport(FeedEntity $feed, \DateTime $scheduleDate = null, $forced = false, $partial = null)
    {
        if (is_null($scheduleDate)) {
            $scheduleDate = new \DateTime();
        }

        if (is_null($partial)) {
            $partial = $feed->isPartial();
        }
        // see if any imports are still unfinished
        $import = $this->findOrCreateImport($feed);

        $exception = null;

        // check if it's a new import
        if (!$import->getId()) {
            $import->setForced($forced);
            $import->setPartial($partial);
            $import->setDatetimeScheduled($scheduleDate);

            // save now: we want the import on record before starting it
            $this->getRepository()->save($import);

            // add parts
            try {
                $this->addImportParts($import);
            } catch (\Exception $e) {
                // temporary store the exception, so we can update the import appropriately
                $exception = $e;
            }
        }

        // finish import right away if we have no parts, without parts it would never be started
        if (count($import->getParts()) === 0) {
            $this->getRepository()->startImport($import);
            $this->getRepository()->finishImport($import);
        }

        // throw the exception, because catch all exceptions are evil
        if ($exception) {
            throw $exception;
        }

        return $import;
    }

    /**
     * @param ImportPart               $part
     * @param EventDispatcherInterface $dispatcher
     *
     * @return ImportJob
     */
    public function createImportJob(ImportPart $part, EventDispatcherInterface $dispatcher = null)
    {
        $import = $part->getImport();
        $feed = $import->getFeed();
        $dispatcher = $dispatcher ?: $this->createEventDispatcher();

        $importer = $this->createImporter($import, $dispatcher, $this->getDefaultImporterOptions($import));
        $reader = $this->createImportPartReader($part, $dispatcher, $this->getDefaultReaderOptions($import));
        $feed = $this->createFeed($feed, $reader, $dispatcher, $this->getDefaultFeedOptions($import));
        $processor = $this->getImportProcessor($import);

        return new ImportJob($part, $feed, $processor, $importer, $this->getRepository());
    }

    /**
     * @param Import                   $import
     * @param EventDispatcherInterface $dispatcher
     * @param array                    $options
     *
     * @return Importer
     */
    protected function createImporter(Import $import, EventDispatcherInterface $dispatcher, array $options = [])
    {
        $type = $this->importRegistry->getImporterType($import->getFeed()->getImporterType());
        $handler = $this->getImportHandler($import);
        $options = array_merge($options, $import->getFeed()->getImporterOptions());

        $builder = $this->importerBuilderFactory->create($dispatcher);

        return $builder->build($type, $import, $handler, $options);
    }

    /**
     * @param Import    $import
     * @param array     $transport
     * @param \DateTime $scheduleDate
     * @param int       $position
     *
     * @return ImportPart
     */
    protected function createImportPart(Import $import, array $transport, \DateTime $scheduleDate = null, $position = null)
    {
        if (is_null($scheduleDate)) {
            $scheduleDate = new \DateTime();
        }

        if (is_null($position)) {
            $positions = $import
                ->getParts()
                ->map(function (ImportPart $part) {
                    return $part->getPosition();
                })
                ->toArray()
            ;

            // add this to ensure we have at least 1 position
            $positions[] = 0;

            $position = max($positions) + 1;
        }

        $part = new ImportPart();
        $part->setPosition($position);
        $part->setTransportConfig($transport);
        $part->setDatetimeScheduled($scheduleDate);
        $part->setImport($import);
        $import->addPart($part);

        $this->getRepository()->savePart($part);

        return $part;
    }

    /**
     * @param Import                   $import
     * @param array                    $transport
     * @param string                   $resourceType
     * @param EventDispatcherInterface $dispatcher
     * @param array                    $options
     *
     * @return ReaderInterface
     */
    protected function createReader(Import $import, array $transport, $resourceType, EventDispatcherInterface $dispatcher, array $options = [])
    {
        $destinationDir = $this->importStorage->getImportDir($import);

        $feed = $import->getFeed();
        $type = $this->importRegistry->getReaderType($feed->getReaderType());
        $builder = $this->readerBuilderFactory->create($dispatcher, $destinationDir);
        $options = array_merge($options, $feed->getReaderOptions());

        return $builder->build($type, $transport, $resourceType, $options);
    }

    /**
     * @param Import                   $import
     * @param EventDispatcherInterface $dispatcher
     * @param array                    $options
     *
     * @return ReaderInterface
     */
    protected function createImportReader(Import $import, EventDispatcherInterface $dispatcher, array $options = [])

    {
        $feed = $import->getFeed();
        $transport = $feed->getTransportConfig();
        $resourceType = ReaderBuilderInterface::RESOURCE_TYPE_MAIN;

        return $this->createReader($import, $transport, $resourceType, $dispatcher, $options);
    }

    /**
     * @param ImportPart               $importPart
     * @param EventDispatcherInterface $dispatcher
     * @param array                    $options
     *
     * @return ReaderInterface
     */
    protected function createImportPartReader(ImportPart $importPart, EventDispatcherInterface $dispatcher, array $options = [])

    {
        $import = $importPart->getImport();
        $transport = $importPart->getTransportConfig();
        $resourceType = ReaderBuilderInterface::RESOURCE_TYPE_PART;

        return $this->createReader($import, $transport, $resourceType, $dispatcher, $options);
    }

    /**
     * @param FeedEntity               $feed
     * @param ReaderInterface          $reader
     * @param EventDispatcherInterface $dispatcher
     * @param array                    $options
     *
     * @return Feed
     */
    protected function createFeed(FeedEntity $feed, ReaderInterface $reader, EventDispatcherInterface $dispatcher, array $options = [])
    {
        $builder = new FeedBuilder($dispatcher);
        $type = $this->importRegistry->getFeedType($feed->getType());
        $options = array_merge($options, $feed->getOptions());

        return $builder->build($type, $reader, $options);
    }

    /**
     * @return EventDispatcherInterface
     */
    protected function createEventDispatcher()
    {
        $dispatcher = new EventDispatcher();
        $dispatcher->addSubscriber($this);

        return $dispatcher;
    }

    /**
     * @param FeedEntity $feed
     *
     * @throws UnfinishedImportException
     *
     * @return Import
     */
    protected function findOrCreateImport(FeedEntity $feed)
    {
        /** @var $imports Import[] */
        $imports = $this->getRepository()->findBy(['feed' => $feed]);

        foreach ($imports as $import) {
            // skip finished imports
            if ($import->isFinished()) {
                continue;
            }

            // if it hasn't started yet, use this one
            if (!$import->isStarted()) {
                return $import;
            }

            try {
                $this->getRepository()->finishImport($import);
            } catch (UnfinishedImportException $e) {
                throw new UnfinishedImportException(
                    $import,
                    sprintf(
                        'Import %d has unfinished parts, close those first before creating a new import',
                        $import->getId()
                    )
                );
            }
        }

        // all previous imports are checked and finished if necessary, we can create a new one now
        $import = new Import();
        $import->setFeed($feed);

        return $import;
    }

    protected function addImportParts(Import $import)
    {
        $dispatcher = $this->createEventDispatcher();
        $options = $this->getDefaultReaderOptions($import);

        $reader = $this->createImportReader($import, $dispatcher, $options);

        foreach ($reader->getResources() as $resource) {
            $transport = TransportFactory::createConfigFromTransport($resource->getTransport());

            $part = $this->createImportPart($import, $transport);
            $this->eventDispatcher->dispatch(ImportEvents::PART_CREATED, new PartEvent($part));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
    }

    /**
     * @return ImportRepository
     */
    protected function getRepository()
    {
        return $this->doctrine->getRepository('TreeHouseIoBundle:Import');
    }

    /**
     * @param Import $import
     *
     * @return HandlerInterface
     */
    protected function getImportHandler(Import $import)

    {
        return $this->importRegistry->getHandler('doctrine');
    }

    /**
     * @param Import $import
     *
     * @return ProcessorInterface
     */
    protected function getImportProcessor(Import $import)

    {
        return $this->importRegistry->getProcessor('posix');
    }

    /**
     * Returns default options to pass to the feed builder.
     *
     * @param Import $import
     *
     * @return array
     */
    protected function getDefaultFeedOptions(Import $import)
    {
        return [
            'forced' => $import->isForced(),
            'feed' => $import->getFeed(),
            'default_values' => $import->getFeed()->getDefaultValues(),
        ];
    }

    /**
     * Returns default options to pass to the reader builder.
     *
     * @param Import $import
     *
     * @return array
     */
    protected function getDefaultReaderOptions(Import $import)
    {
        return [
            'partial' => $import->isPartial(),
            'forced' => $import->isForced(),
        ];
    }

    /**
     * Returns default options to pass to the importer builder.
     *
     * @param Import $import
     *
     * @return array
     */
    protected function getDefaultImporterOptions(Import $import)

    {
        return [];
    }
}


1			<?php
2
3			namespace TreeHouse\IoBundle\Import;
4
5			use Doctrine\Common\Persistence\ManagerRegistry;
6			use Symfony\Component\EventDispatcher\Event;
7			use Symfony\Component\EventDispatcher\EventDispatcher;
8			use Symfony\Component\EventDispatcher\EventDispatcherInterface;
9			use Symfony\Component\EventDispatcher\EventSubscriberInterface;
10			use TreeHouse\Feeder\Exception\ReadException;
11			use TreeHouse\Feeder\Feed;
12			use TreeHouse\Feeder\FeedEvents;
13			use TreeHouse\Feeder\Reader\ReaderInterface;
14			use TreeHouse\IoBundle\Entity\Feed as FeedEntity;
15			use TreeHouse\IoBundle\Entity\Import;
16			use TreeHouse\IoBundle\Entity\ImportPart;
17			use TreeHouse\IoBundle\Entity\ImportRepository;
18			use TreeHouse\IoBundle\Exception\UnfinishedImportException;
19			use TreeHouse\IoBundle\Import\Event\ExceptionEvent;
20			use TreeHouse\IoBundle\Import\Event\PartEvent;
21			use TreeHouse\IoBundle\Import\Feed\FeedBuilder;
22			use TreeHouse\IoBundle\Import\Feed\TransportFactory;
23			use TreeHouse\IoBundle\Import\Handler\HandlerInterface;
24			use TreeHouse\IoBundle\Import\Importer\Importer;
25			use TreeHouse\IoBundle\Import\Importer\ImporterBuilderFactory;
26			use TreeHouse\IoBundle\Import\Log\ItemLoggerInterface;
27			use TreeHouse\IoBundle\Import\Processor\ProcessorInterface;
28			use TreeHouse\IoBundle\Import\Reader\ReaderBuilderFactory;
29			use TreeHouse\IoBundle\Import\Reader\ReaderBuilderInterface;
30
31			class ImportFactory implements EventSubscriberInterface
32			{
33			/**
34			* @var ManagerRegistry
35			*/
36			protected $doctrine;
37
38			/**
39			* @var ImportRegistry
40			*/
41			protected $importRegistry;
42
43			/**
44			* @var ImporterBuilderFactory
45			*/
46			protected $importerBuilderFactory;
47
48			/**
49			* @var ReaderBuilderFactory
50			*/
51			protected $readerBuilderFactory;
52
53			/**
54			* @var ImportStorage
55			*/
56			protected $importStorage;
57
58			/**
59			* @var EventDispatcherInterface
60			*/
61			protected $eventDispatcher;
62
63			/**
64			* @param ManagerRegistry $doctrine
65			* @param ImportRegistry $importRegistry
66			* @param ImporterBuilderFactory $importerBuilderFactory
67			* @param ReaderBuilderFactory $readerBuilderFactory
68			* @param ImportStorage $importStorage
69			* @param EventDispatcherInterface $dispatcher
70			*/
71	4		public function __construct(
72			ManagerRegistry $doctrine,
73			ImportRegistry $importRegistry,
74			ImporterBuilderFactory $importerBuilderFactory,
75			ReaderBuilderFactory $readerBuilderFactory,
76			ImportStorage $importStorage,
77			EventDispatcherInterface $dispatcher
78			) {
79	4		$this->doctrine = $doctrine;
80	4		$this->importRegistry = $importRegistry;
81	4		$this->importerBuilderFactory = $importerBuilderFactory;
82	4		$this->readerBuilderFactory = $readerBuilderFactory;
83	4		$this->importStorage = $importStorage;
84	4		$this->eventDispatcher = $dispatcher;
85	4		}
86
87			/**
88			* @return EventDispatcherInterface
89			*/
90			public function getEventDispatcher()
91			{
92			return $this->eventDispatcher;
93			}
94
95			/**
96			* @inheritdoc
97			*/
98	4		public static function getSubscribedEvents()
99			{
100	4		$events = [];
101
102	4		foreach ([FeedEvents::class, ImportEvents::class] as $class) {
103	4		$refl = new \ReflectionClass($class);
104	4		foreach ($refl->getConstants() as $constant) {
105	4		$events[$constant][] = 'relayEvent';
106			}
107			}
108
109	4		$events[ImportEvents::EXCEPTION][] = 'onException';
110
111	4		return $events;
112			}
113
114			/**
115			* Relays an event to the main dispatcher in the manager.
116			* This is done so listeners can subscribe to this class,
117			* while each importer starts with a new dispatcher.
118
119			* @param Event $event
120			* @param string $name
121			*/
122	4		public function relayEvent(Event $event, $name)
123			{
124	4		$this->eventDispatcher->dispatch($name, $event);
			0 ignored issues – show Documentation introduced 2020-05-04 12:22 UTC by Report Bug Copy Issue Report `$name` is of type `string`, but the function expects a `object<Symfony\Contracts\EventDispatcher\object>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history... Documentation introduced 2020-05-04 12:22 UTC by Report Bug Copy Issue Report `$event` is of type `object<Symfony\Component\EventDispatcher\Event>`, but the function expects a `null\|string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
125	4		}
126
127			/**
128			* Handler for an exception event. Importer types can listen to the same
129			* event and stop propagation if they want to change this behaviour.
130			*
131			* @param ExceptionEvent $event
132			*
133			* @throws \RuntimeException
134			*/
135			public function onException(ExceptionEvent $event)
136			{
137			$exception = $event->getException();
138			if ($exception instanceof ReadException) {
139			$msg = sprintf('Error reading feed: %s', $exception->getMessage());
140			} else {
141			$msg = sprintf(
142			'Import aborted with %s: "%s" Stack trace: %s',
143			get_class($exception),
144			$exception->getMessage(),
145			$exception->getTraceAsString()
146			);
147			}
148
149			throw new \RuntimeException($msg, 0, $exception);
150			}
151
152			/**
153			* @param ItemLoggerInterface $logger
154			*/
155	4		public function setItemLogger(ItemLoggerInterface $logger)
156			{
157	4		$this->eventDispatcher->addSubscriber($logger);
158	4		}
159
160			/**
161			* Creates an import for a feed. If an import for this feed was created
162			* before, but has not started yet, that import is returned. All other open
163			* imports are closed first.
164			*
165			* @param FeedEntity $feed The feed to create the import for
166			* @param \DateTime $scheduleDate The date this import should start
167			* @param bool $forced Whether to handle items that would normally be skipped
168			* @param bool $partial If left out, it will be determined based on feed
169			*
170			* @throws UnfinishedImportException When an existing (and running) import is found
171			*
172			* @return Import
173			*/
174	4		public function createImport(FeedEntity $feed, \DateTime $scheduleDate = null, $forced = false, $partial = null)
175			{
176	4		if (is_null($scheduleDate)) {
177			$scheduleDate = new \DateTime();
178			}
179
180	4		if (is_null($partial)) {
181	4		$partial = $feed->isPartial();
182			}
183			// see if any imports are still unfinished
184	4		$import = $this->findOrCreateImport($feed);
185
186	4		$exception = null;
187
188			// check if it's a new import
189	4		if (!$import->getId()) {
190	4		$import->setForced($forced);
191	4		$import->setPartial($partial);
192	4		$import->setDatetimeScheduled($scheduleDate);
193
194			// save now: we want the import on record before starting it
195	4		$this->getRepository()->save($import);
196
197			// add parts
198			try {
199	4		$this->addImportParts($import);
200			} catch (\Exception $e) {
201			// temporary store the exception, so we can update the import appropriately
202			$exception = $e;
203			}
204			}
205
206			// finish import right away if we have no parts, without parts it would never be started
207	4		if (count($import->getParts()) === 0) {
208			$this->getRepository()->startImport($import);
209			$this->getRepository()->finishImport($import);
210			}
211
212			// throw the exception, because catch all exceptions are evil
213	4		if ($exception) {
214			throw $exception;
215			}
216
217	4		return $import;
218			}
219
220			/**
221			* @param ImportPart $part
222			* @param EventDispatcherInterface $dispatcher
223			*
224			* @return ImportJob
225			*/
226	4		public function createImportJob(ImportPart $part, EventDispatcherInterface $dispatcher = null)
227			{
228	4		$import = $part->getImport();
229	4		$feed = $import->getFeed();
230	4		$dispatcher = $dispatcher ?: $this->createEventDispatcher();
231
232	4		$importer = $this->createImporter($import, $dispatcher, $this->getDefaultImporterOptions($import));
233	4		$reader = $this->createImportPartReader($part, $dispatcher, $this->getDefaultReaderOptions($import));
234	4		$feed = $this->createFeed($feed, $reader, $dispatcher, $this->getDefaultFeedOptions($import));
235	4		$processor = $this->getImportProcessor($import);
236
237	4		return new ImportJob($part, $feed, $processor, $importer, $this->getRepository());
238			}
239
240			/**
241			* @param Import $import
242			* @param EventDispatcherInterface $dispatcher
243			* @param array $options
244			*
245			* @return Importer
246			*/
247	4		protected function createImporter(Import $import, EventDispatcherInterface $dispatcher, array $options = [])
248			{
249	4		$type = $this->importRegistry->getImporterType($import->getFeed()->getImporterType());
250	4		$handler = $this->getImportHandler($import);
251	4		$options = array_merge($options, $import->getFeed()->getImporterOptions());
252
253	4		$builder = $this->importerBuilderFactory->create($dispatcher);
254
255	4		return $builder->build($type, $import, $handler, $options);
256			}
257
258			/**
259			* @param Import $import
260			* @param array $transport
261			* @param \DateTime $scheduleDate
262			* @param int $position
263			*
264			* @return ImportPart
265			*/
266	4		protected function createImportPart(Import $import, array $transport, \DateTime $scheduleDate = null, $position = null)
267			{
268	4		if (is_null($scheduleDate)) {
269	4		$scheduleDate = new \DateTime();
270			}
271
272	4		if (is_null($position)) {
273			$positions = $import
274	4		->getParts()
275	4		->map(function (ImportPart $part) {
276			return $part->getPosition();
277	4		})
278	4		->toArray()
279			;
280
281			// add this to ensure we have at least 1 position
282	4		$positions[] = 0;
283
284	4		$position = max($positions) + 1;
285			}
286
287	4		$part = new ImportPart();
288	4		$part->setPosition($position);
289	4		$part->setTransportConfig($transport);
290	4		$part->setDatetimeScheduled($scheduleDate);
291	4		$part->setImport($import);
292	4		$import->addPart($part);
293
294	4		$this->getRepository()->savePart($part);
295
296	4		return $part;
297			}
298
299			/**
300			* @param Import $import
301			* @param array $transport
302			* @param string $resourceType
303			* @param EventDispatcherInterface $dispatcher
304			* @param array $options
305			*
306			* @return ReaderInterface
307			*/
308	4		protected function createReader(Import $import, array $transport, $resourceType, EventDispatcherInterface $dispatcher, array $options = [])
309			{
310	4		$destinationDir = $this->importStorage->getImportDir($import);
311
312	4		$feed = $import->getFeed();
313	4		$type = $this->importRegistry->getReaderType($feed->getReaderType());
314	4		$builder = $this->readerBuilderFactory->create($dispatcher, $destinationDir);
315	4		$options = array_merge($options, $feed->getReaderOptions());
316
317	4		return $builder->build($type, $transport, $resourceType, $options);
318			}
319
320			/**
321			* @param Import $import
322			* @param EventDispatcherInterface $dispatcher
323			* @param array $options
324			*
325			* @return ReaderInterface
326			*/
327	4	View Code Duplication	protected function createImportReader(Import $import, EventDispatcherInterface $dispatcher, array $options = [])
			0 ignored issues – show Duplication introduced 2017-10-04 10:43 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
328			{
329	4		$feed = $import->getFeed();
330	4		$transport = $feed->getTransportConfig();
331	4		$resourceType = ReaderBuilderInterface::RESOURCE_TYPE_MAIN;
332
333	4		return $this->createReader($import, $transport, $resourceType, $dispatcher, $options);
334			}
335
336			/**
337			* @param ImportPart $importPart
338			* @param EventDispatcherInterface $dispatcher
339			* @param array $options
340			*
341			* @return ReaderInterface
342			*/
343	4	View Code Duplication	protected function createImportPartReader(ImportPart $importPart, EventDispatcherInterface $dispatcher, array $options = [])
			0 ignored issues – show Duplication introduced 2017-10-04 10:43 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
344			{
345	4		$import = $importPart->getImport();
346	4		$transport = $importPart->getTransportConfig();
347	4		$resourceType = ReaderBuilderInterface::RESOURCE_TYPE_PART;
348
349	4		return $this->createReader($import, $transport, $resourceType, $dispatcher, $options);
350			}
351
352			/**
353			* @param FeedEntity $feed
354			* @param ReaderInterface $reader
355			* @param EventDispatcherInterface $dispatcher
356			* @param array $options
357			*
358			* @return Feed
359			*/
360	4		protected function createFeed(FeedEntity $feed, ReaderInterface $reader, EventDispatcherInterface $dispatcher, array $options = [])
361			{
362	4		$builder = new FeedBuilder($dispatcher);
363	4		$type = $this->importRegistry->getFeedType($feed->getType());
364	4		$options = array_merge($options, $feed->getOptions());
365
366	4		return $builder->build($type, $reader, $options);
367			}
368
369			/**
370			* @return EventDispatcherInterface
371			*/
372	4		protected function createEventDispatcher()
373			{
374	4		$dispatcher = new EventDispatcher();
375	4		$dispatcher->addSubscriber($this);
376
377	4		return $dispatcher;
378			}
379
380			/**
381			* @param FeedEntity $feed
382			*
383			* @throws UnfinishedImportException
384			*
385			* @return Import
386			*/
387	4		protected function findOrCreateImport(FeedEntity $feed)
388			{
389			/** @var $imports Import[] */
390	4		$imports = $this->getRepository()->findBy(['feed' => $feed]);
391
392	4		foreach ($imports as $import) {
393			// skip finished imports
394	2		if ($import->isFinished()) {
395	2		continue;
396			}
397
398			// if it hasn't started yet, use this one
399			if (!$import->isStarted()) {
400			return $import;
401			}
402
403			try {
404			$this->getRepository()->finishImport($import);
405			} catch (UnfinishedImportException $e) {
406			throw new UnfinishedImportException(
407			$import,
408			sprintf(
409			'Import %d has unfinished parts, close those first before creating a new import',
410			$import->getId()
411			)
412			);
413			}
414			}
415
416			// all previous imports are checked and finished if necessary, we can create a new one now
417	4		$import = new Import();
418	4		$import->setFeed($feed);
419
420	4		return $import;
421			}
422
423	4		protected function addImportParts(Import $import)
424			{
425	4		$dispatcher = $this->createEventDispatcher();
426	4		$options = $this->getDefaultReaderOptions($import);
427
428	4		$reader = $this->createImportReader($import, $dispatcher, $options);
429
430	4		foreach ($reader->getResources() as $resource) {
431	4		$transport = TransportFactory::createConfigFromTransport($resource->getTransport());
432
433	4		$part = $this->createImportPart($import, $transport);
434	4		$this->eventDispatcher->dispatch(ImportEvents::PART_CREATED, new PartEvent($part));
			0 ignored issues – show Documentation introduced 2020-05-04 12:22 UTC by Report Bug Copy Issue Report `new \TreeHouse\IoBundle\...\Event\PartEvent($part)` is of type `object<TreeHouse\IoBundle\Import\Event\PartEvent>`, but the function expects a `null\|string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
435			}
436	4		}
437
438			/**
439			* @return ImportRepository
440			*/
441	4		protected function getRepository()
442			{
443	4		return $this->doctrine->getRepository('TreeHouseIoBundle:Import');
444			}
445
446			/**
447			* @param Import $import
448			*
449			* @return HandlerInterface
450			*/
451	4		protected function getImportHandler(Import $import)
			0 ignored issues – show Unused Code introduced 2017-10-04 10:43 UTC by Report Bug Copy Issue Report The parameter `$import` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
452			{
453	4		return $this->importRegistry->getHandler('doctrine');
454			}
455
456			/**
457			* @param Import $import
458			*
459			* @return ProcessorInterface
460			*/
461	4		protected function getImportProcessor(Import $import)
			0 ignored issues – show Unused Code introduced 2017-10-04 10:43 UTC by Report Bug Copy Issue Report The parameter `$import` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
462			{
463	4		return $this->importRegistry->getProcessor('posix');
464			}
465
466			/**
467			* Returns default options to pass to the feed builder.
468			*
469			* @param Import $import
470			*
471			* @return array
472			*/
473	4		protected function getDefaultFeedOptions(Import $import)
474			{
475			return [
476	4		'forced' => $import->isForced(),
477	4		'feed' => $import->getFeed(),
478	4		'default_values' => $import->getFeed()->getDefaultValues(),
479			];
480			}
481
482			/**
483			* Returns default options to pass to the reader builder.
484			*
485			* @param Import $import
486			*
487			* @return array
488			*/
489	4		protected function getDefaultReaderOptions(Import $import)
490			{
491			return [
492	4		'partial' => $import->isPartial(),
493	4		'forced' => $import->isForced(),
494			];
495			}
496
497			/**
498			* Returns default options to pass to the importer builder.
499			*
500			* @param Import $import
501			*
502			* @return array
503			*/
504	4		protected function getDefaultImporterOptions(Import $import)
			0 ignored issues – show Unused Code introduced 2017-10-04 10:43 UTC by Report Bug Copy Issue Report The parameter `$import` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
505			{
506	4		return [];
507			}
508			}
509

treehouselabs / io-bundle

ImportFactory::createImportJob() A last analyzed 2020-05-04 12:22 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ImportFactory::createImportJob() A
last analyzed 2020-05-04 12:22 UTC