TreeHouse\IoBundle\Import\Importer\Importer

Complexity

Total Complexity

24

Size/Duplication

Total Lines	275
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Test Coverage

Coverage

79.52%

Importance

Changes	3
Bugs	2	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	getImport()	0	4	1
A	getResult()	0	4	1
A	getSubscribedEvents()	0	8	1
A	getEventDispatcher()	0	4	1
A	setBatchSize()	0	10	2
A	onItemFiltered()	0	4	1
A	onItemFailed()	0	4	1
A	onItemInvalid()	0	4	1
A	dispatchEvent()	0	4	1
B	run()	0	29	4
A	getNextItem()	0	10	2
A	handleItem()	0	15	1
A	successItem()	0	7	1
A	skipItem()	0	7	1
A	failItem()	0	7	1
A	handleException()	0	4	1
A	flush()	0	4	1
A	clear()	0	4	1

<?php

namespace TreeHouse\IoBundle\Import\Importer;

use Symfony\Component\EventDispatcher\Event;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use TreeHouse\Feeder\Event\InvalidItemEvent;
use TreeHouse\Feeder\Event\ItemNotModifiedEvent;
use TreeHouse\Feeder\Feed;
use TreeHouse\Feeder\FeedEvents;
use TreeHouse\IoBundle\Entity\Import;
use TreeHouse\IoBundle\Import\Event\ExceptionEvent;
use TreeHouse\IoBundle\Import\Event\FailedItemEvent;
use TreeHouse\IoBundle\Import\Event\HandledItemEvent;
use TreeHouse\IoBundle\Import\Event\ItemEvent;
use TreeHouse\IoBundle\Import\Event\SkippedItemEvent;
use TreeHouse\IoBundle\Import\Event\SuccessItemEvent;
use TreeHouse\IoBundle\Import\Exception\FailedItemException;
use TreeHouse\IoBundle\Import\Feed\FeedItemBag;
use TreeHouse\IoBundle\Import\Handler\HandlerInterface;
use TreeHouse\IoBundle\Import\ImportEvents;
use TreeHouse\IoBundle\Import\ImportResult;
use TreeHouse\IoBundle\Model\SourceInterface;

class Importer implements EventSubscriberInterface
{
    /**
     * @var Import
     */
    protected $import;

    /**
     * @var HandlerInterface
     */
    protected $handler;

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

    /**
     * @var ImportResult
     */
    protected $result;

    /**
     * @var int
     */
    protected $batchSize = 20;

    /**
     * @param Import                   $import
     * @param HandlerInterface         $handler
     * @param EventDispatcherInterface $dispatcher
     * @param int                      $batchSize
     */
    public function __construct(Import $import, HandlerInterface $handler, EventDispatcherInterface $dispatcher, $batchSize = 20)
    {
        $this->import = $import;
        $this->handler = $handler;
        $this->eventDispatcher = $dispatcher;
        $this->result = new ImportResult();

        $this->setBatchSize($batchSize);
        $this->eventDispatcher->addSubscriber($this);
    }

    /**
     * @return Import
     */
    public function getImport()
    {
        return $this->import;
    }

    /**
     * @return ImportResult
     */
    public function getResult()
    {
        return $this->result;
    }

    /**
     * @inheritdoc
     */
    public static function getSubscribedEvents()
    {
        return [
            FeedEvents::ITEM_FILTERED => [['onItemFiltered']],
            FeedEvents::ITEM_INVALID => [['onItemInvalid']],
            FeedEvents::ITEM_FAILED => [['onItemFailed']],
        ];
    }

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

    /**
     * @param int $size
     *
     * @throws \InvalidArgumentException When size is not a positive number
     */
    public function setBatchSize($size)
    {
        $batchSize = intval($size);

        if ($batchSize < 1) {
            throw new \InvalidArgumentException('Batch size needs to be higher than 0');
        }

        $this->batchSize = $batchSize;
    }

    /**
     * Dispatched when item is filtered from the feed.
     *
     * @param ItemNotModifiedEvent $event
     */
    public function onItemFiltered(ItemNotModifiedEvent $event)
    {
        $this->skipItem($event->getItem(), $event->getReason());

$event->getItem() of type object<Symfony\Component\HttpFoundation\ParameterBag> is not a sub-type of object<TreeHouse\IoBundle\Import\Feed\FeedItemBag>. It seems like you assume a child class of the class Symfony\Component\HttpFoundation\ParameterBag to be always present.

    }

    /**
     * Dispatched when item failed during modification.
     *
     * @param ItemNotModifiedEvent $event
     */
    public function onItemFailed(ItemNotModifiedEvent $event)
    {
        $this->failItem($event->getItem(), $event->getReason());

$event->getItem() of type object<Symfony\Component\HttpFoundation\ParameterBag> is not a sub-type of object<TreeHouse\IoBundle\Import\Feed\FeedItemBag>. It seems like you assume a child class of the class Symfony\Component\HttpFoundation\ParameterBag to be always present.

    }

    /**
     * Dispatched when item is processed but found invalid.
     *
     * @param InvalidItemEvent $event
     */
    public function onItemInvalid(InvalidItemEvent $event)
    {
        $this->failItem($event->getItem(), $event->getReason());

$event->getItem() of type object<Symfony\Component\HttpFoundation\ParameterBag> is not a sub-type of object<TreeHouse\IoBundle\Import\Feed\FeedItemBag>. It seems like you assume a child class of the class Symfony\Component\HttpFoundation\ParameterBag to be always present.

    }

    /**
     * @param string $name
     * @param Event  $event
     */
    public function dispatchEvent($name, Event $event)
    {
        $this->eventDispatcher->dispatch($name, $event);
    }

    /**
     * Runs the import.
     *
     * @param Feed $feed
     */
    public function run(Feed $feed)
    {
        while ($item = $this->getNextItem($feed)) {
            // dispatch event for next item
            $event = new ItemEvent($this, $item);

$item of type object<Symfony\Component\HttpFoundation\ParameterBag> is not a sub-type of object<TreeHouse\IoBundle\Item\ItemBag>. It seems like you assume a child class of the class Symfony\Component\HttpFoundation\ParameterBag to be always present.

            $this->eventDispatcher->dispatch(ImportEvents::ITEM_START, $event);
            // import the item
            try {
                $source = $this->handleItem($item);

$item of type object<Symfony\Component\HttpFoundation\ParameterBag> is not a sub-type of object<TreeHouse\IoBundle\Import\Feed\FeedItemBag>. It seems like you assume a child class of the class Symfony\Component\HttpFoundation\ParameterBag to be always present.

                $this->successItem($item, $source);

$item of type object<Symfony\Component\HttpFoundation\ParameterBag> is not a sub-type of object<TreeHouse\IoBundle\Import\Feed\FeedItemBag>. It seems like you assume a child class of the class Symfony\Component\HttpFoundation\ParameterBag to be always present.

            } catch (FailedItemException $e) {
                $this->failItem($item, $e->getMessage());

$item of type object<Symfony\Component\HttpFoundation\ParameterBag> is not a sub-type of object<TreeHouse\IoBundle\Import\Feed\FeedItemBag>. It seems like you assume a child class of the class Symfony\Component\HttpFoundation\ParameterBag to be always present.

            }

            // item done
            $this->eventDispatcher->dispatch(ImportEvents::ITEM_FINISH, $event);

            // clear entitymanager after batch
            if (($this->result->getProcessed() % $this->batchSize) === 0) {
                $this->flush();
                $this->clear();
            }
        }

        // flush remaining changes
        $this->flush();
        $this->clear();
    }

    /**
     * Returns the next item in the feed, or null if no more items are left.
     * Use this when iterating over the feed.
     *
     * @param Feed $feed
     *
     * @return FeedItemBag|null
     */
    protected function getNextItem(Feed $feed)
    {
        try {
            return $feed->getNextItem();
        } catch (\Exception $exception) {
            $this->handleException($exception);
        }

        return null;
    }

    /**
     * @param FeedItemBag $item
     *
     * @return SourceInterface
     */
    protected function handleItem(FeedItemBag $item)
    {
        $source = $this->handler->handle($item);

        $this->eventDispatcher->dispatch(
            ImportEvents::ITEM_HANDLED,
            new HandledItemEvent(
                $this,
                $item,
                $source
            )
        );

        return $source;
    }

    /**
     * Dispatches an event indicating a successfully handled item.
     *
     * @param FeedItemBag     $item
     * @param SourceInterface $result
     */
    protected function successItem(FeedItemBag $item, SourceInterface $result)
    {
        $this->result->incrementSuccess();

        $event = new SuccessItemEvent($this, $item, $result);
        $this->eventDispatcher->dispatch(ImportEvents::ITEM_SUCCESS, $event);
    }

    /**
     * Dispatches an event indicating a skipped item.
     *
     * @param FeedItemBag $item
     * @param string      $reason
     */
    protected function skipItem(FeedItemBag $item, $reason = '')
    {
        $this->result->incrementSkipped();

        $event = new SkippedItemEvent($this, $item, $reason);
        $this->eventDispatcher->dispatch(ImportEvents::ITEM_SKIPPED, $event);
    }

    /**
     * Dispatches an event indicating a failed item.
     *
     * @param FeedItemBag $item
     * @param string      $reason
     */
    protected function failItem(FeedItemBag $item, $reason)
    {
        $this->result->incrementFailed();

        $event = new FailedItemEvent($this, $item, $reason);
        $this->eventDispatcher->dispatch(ImportEvents::ITEM_FAILED, $event);
    }

    /**
     * Dispatches exception event.
     *
     * @param \Exception $exception
     */
    protected function handleException(\Exception $exception)
    {
        $this->eventDispatcher->dispatch(ImportEvents::EXCEPTION, new ExceptionEvent($this, $exception));
    }

    /**
     * Flushes outstanding changes.
     */
    protected function flush()
    {
        $this->handler->flush();
    }

    protected function clear()
    {
        $this->handler->clear();
    }
}