Mathielen\DataImport\EventDispatchableWorkflow

Complexity

Total Complexity

19

Size/Duplication

Total Lines	132
Duplicated Lines	12.12 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

86.44%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	setEventDispatcher()	0	4	1
B	process()	0	56	8
A	prepare()	0	10	2
A	finish()	0	10	2
A	processRead()	0	4	1
A	processFilter()	8	8	1
A	processConvert()	0	8	1
A	processConvertFilter()	8	8	1
A	processWrite()	0	8	2

<?php

namespace Mathielen\DataImport;

use Ddeboer\DataImport\Result;
use Ddeboer\DataImport\Workflow as OriginalWorkflow;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Mathielen\DataImport\Event\ImportProcessEvent;
use Mathielen\DataImport\Event\ImportItemEvent;
use Ddeboer\DataImport\Exception\ExceptionInterface;

class EventDispatchableWorkflow extends OriginalWorkflow
{
    /**
     * @var EventDispatcherInterface
     */
    private $eventDispatcher;

    public function setEventDispatcher(EventDispatcherInterface $eventDispatcher)
    {
        $this->eventDispatcher = $eventDispatcher;
    }

    public function process()
    {
        //if no eventdispatcher has been set, use original functionality
        if (!$this->eventDispatcher) {
            return parent::process();
        }

        $count = 0;
        $exceptions = array();
        $startTime = new \DateTime();
        $importProcessEvent = new ImportProcessEvent();

        //Prepare
        $this->prepare($importProcessEvent);

        // Read all items
        foreach ($this->reader as $item) {
            //only create event once for every item-event for performance reasons
            $event = $importProcessEvent->newItemEvent($item);

            try {
                $this->processRead($item, $event);

                // Apply filters before conversion
                if (!$this->processFilter($item, $event)) {
                    continue;
                }

                // Convert item
                if (!$convertedItem = $this->processConvert($item, $event)) {
                    continue;
                }

                // Apply filters after conversion
                if (!$this->processConvertFilter($convertedItem, $event)) {
                    continue;
                }

                $this->processWrite($convertedItem, $item, $event);
            } catch (ExceptionInterface $e) {
                if ($this->skipItemOnFailure) {
                    $exceptions[] = $e;
                    $this->logger->error($e->getMessage());
                } else {
                    throw $e;
                }
            }

            ++$count;
        }

        //Finish
        $this->finish($importProcessEvent);

        return new Result($this->name, $startTime, new \DateTime(), $count, $exceptions);
    }

    private function prepare(ImportProcessEvent $importProcessEvent)
    {
        //Prepare writers
        foreach ($this->writers as $writer) {
            $writer->prepare();
        }

        //Send global event
        $this->eventDispatcher->dispatch(ImportProcessEvent::AFTER_PREPARE, $importProcessEvent);

$importProcessEvent is of type object<Mathielen\DataImport\Event\ImportProcessEvent>, but the function expects a null|string.

    }

    private function finish(ImportProcessEvent $importProcessEvent)
    {
        // Finish writers
        foreach ($this->writers as $writer) {
            $writer->finish();
        }

        //Send global event
        $this->eventDispatcher->dispatch(ImportProcessEvent::AFTER_FINISH, $importProcessEvent);

$importProcessEvent is of type object<Mathielen\DataImport\Event\ImportProcessEvent>, but the function expects a null|string.

    }

    protected function processRead(array $item, ImportItemEvent $event)
    {
        $this->eventDispatcher->dispatch(ImportItemEvent::AFTER_READ, $event);

$event is of type object<Mathielen\DataImport\Event\ImportItemEvent>, but the function expects a null|string.

    }

    protected function processFilter(array $item, ImportItemEvent $event)

This method seems to be duplicated in your project.

    {
        $filterResult = $this->filterItem($item, $this->filters);

It seems like $this->filters can also be of type array<integer,object<Ddeboer\DataImport\Filter\FilterInterface>>; however, Ddeboer\DataImport\Workflow::filterItem() does only seem to accept object<SplPriorityQueue>, maybe add an additional type check?

        $this->eventDispatcher->dispatch(ImportItemEvent::AFTER_FILTER, $event->setCurrentResult($filterResult));

$event->setCurrentResult($filterResult) is of type object<Mathielen\DataImport\Event\ImportItemEvent>, but the function expects a null|string.

        return $filterResult;
    }

    protected function processConvert(array $item, ImportItemEvent $event)
    {
        $convertedItem = $this->convertItem($item);

$item is of type array, but the function expects a string.

        $this->eventDispatcher->dispatch(ImportItemEvent::AFTER_FILTER, $event->setCurrentResult($convertedItem));

$event->setCurrentResult($convertedItem) is of type object<Mathielen\DataImport\Event\ImportItemEvent>, but the function expects a null|string.

        return $convertedItem;
    }

    protected function processConvertFilter(array $item, ImportItemEvent $event)

This method seems to be duplicated in your project.

    {
        $filterResult = $this->filterItem($item, $this->afterConversionFilters);

It seems like $this->afterConversionFilters can also be of type array<integer,object<Ddeboer\DataImport\Filter\FilterInterface>>; however, Ddeboer\DataImport\Workflow::filterItem() does only seem to accept object<SplPriorityQueue>, maybe add an additional type check?

        $this->eventDispatcher->dispatch(ImportItemEvent::AFTER_CONVERSIONFILTER, $event->setCurrentResult($filterResult));

$event->setCurrentResult($filterResult) is of type object<Mathielen\DataImport\Event\ImportItemEvent>, but the function expects a null|string.

        return $filterResult;
    }

    protected function processWrite(array $convertedItem, array $item, ImportItemEvent $event)
    {
        foreach ($this->writers as $writer) {
            $writer->writeItem($convertedItem, $item);
        }

        $this->eventDispatcher->dispatch(ImportItemEvent::AFTER_WRITE, $event);

$event is of type object<Mathielen\DataImport\Event\ImportItemEvent>, but the function expects a null|string.

    }
}