OroCRM\Bundle\MagentoBundle\ImportExport\Writer\ProxyEntityWriter

Complexity

Total Complexity

19

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	4
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	handleIdentifier()	0	12	4
A	__construct()	0	6	1
D	write()	0	28	9
A	setStepExecution()	0	6	2
A	restoreStepExecution()	0	6	2
A	logSkipped()	0	6	1

<?php

namespace OroCRM\Bundle\MagentoBundle\ImportExport\Writer;

use Psr\Log\NullLogger;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\LoggerAwareInterface;

use Akeneo\Bundle\BatchBundle\Entity\StepExecution;
use Akeneo\Bundle\BatchBundle\Item\ItemWriterInterface;
use Akeneo\Bundle\BatchBundle\Step\StepExecutionAwareInterface;

use Oro\Bundle\BatchBundle\Step\StepExecutionRestoreInterface;

use Oro\Bundle\ImportExportBundle\Field\DatabaseHelper;

use OroCRM\Bundle\MagentoBundle\Entity\Cart;
use OroCRM\Bundle\MagentoBundle\Entity\Order;
use OroCRM\Bundle\MagentoBundle\Entity\Customer;
use OroCRM\Bundle\MagentoBundle\Entity\NewsletterSubscriber;

class ProxyEntityWriter implements
    ItemWriterInterface,
    StepExecutionAwareInterface,
    StepExecutionRestoreInterface,
    LoggerAwareInterface
{
    use LoggerAwareTrait;

    /** @var ItemWriterInterface */
    protected $writer;

    /** @var DatabaseHelper */
    protected $databaseHelper;

    /** @var StepExecution|null */
    protected $previousStepExecution;

    /**
     * @param ItemWriterInterface $writer
     * @param DatabaseHelper $databaseHelper
     */
    public function __construct(ItemWriterInterface $writer, DatabaseHelper $databaseHelper)
    {
        $this->writer = $writer;
        $this->databaseHelper = $databaseHelper;
        $this->logger = new NullLogger();
    }

    /**
     * {@inheritdoc}
     *
     * Prepare items for PersistentBatchWriter, filters for duplicates and takes only latest versions
     */
    public function write(array $items)
    {
        $uniqueItems = [];
        $uniqueKeys = [];
        foreach ($items as $item) {
            if ($item instanceof Customer || $item instanceof Cart) {
                $this->handleIdentifier($uniqueItems, $item, $item->getOriginId());
            } elseif ($item instanceof Order) {
                $this->handleIdentifier($uniqueItems, $item, $item->getIncrementId());
            } elseif ($item instanceof NewsletterSubscriber) {
                $identifier = $item->getCustomer() ? $item->getCustomer()->getId() : 0;
                if ($identifier !== 0 && in_array($identifier, $uniqueKeys)) {
                    $this->logSkipped($item->getOriginId());
                } else {
                    $uniqueKeys[] = $identifier;
                    $uniqueItems[] = $item;
                }

            } else {
                $uniqueItems[] = $item;
            }
        }

        $this->writer->write($uniqueItems);

        // force entity cache clear if clear is skipped
        $this->databaseHelper->onClear();
    }

    /**
     * {@inheritdoc}
     */
    public function setStepExecution(StepExecution $stepExecution)
    {
        if ($this->writer instanceof StepExecutionAwareInterface) {
            $this->writer->setStepExecution($stepExecution);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function restoreStepExecution()
    {
        if ($this->writer instanceof StepExecutionRestoreInterface) {
            $this->writer->restoreStepExecution();
        }
    }

    /**
     * @param array $uniqueItems
     * @param object $item
     * @param string|null $identifier
     */
    protected function handleIdentifier(array &$uniqueItems, $item, $identifier = null)
    {
        if ($identifier && array_key_exists($identifier, $uniqueItems)) {

The expression $identifier of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $this->logSkipped($identifier);
        }

        if ($identifier) {

The expression $identifier of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $uniqueItems[$identifier] = $item;
        } else {
            $uniqueItems[spl_object_hash($item)] = $item;
        }
    }

    /**
     * @param int|string $identifier
     */
    protected function logSkipped($identifier)
    {
        $this->logger->info(
            sprintf('[origin_id=%s] Item skipped because of newer version found', (string)$identifier)
        );
    }
}