TechDivision\Import\Product\Subjects\BunchSubject

Complexity

Total Complexity

17

Size/Duplication

Total Lines	305
Duplicated Lines	9.84 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

24%

Importance

Changes	3
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	12	1
A	tearDown()	0	17	1
A	getDefaultCallbackMappings()	0	4	1
A	getHeaderStockMappings()	0	4	1
A	getVisibilityIdByValue()	0	16	2
A	addEntityIdVisibilityIdMapping()	0	4	1
A	getEntityIdVisibilityIdMapping()	15	15	2
A	addProductCategoryId()	0	4	1
A	preLoadEntityId()	0	4	1
A	getProductCategoryIds()	0	14	2
A	getEntityType()	15	15	2
A	isUrlKeyOf()	0	4	2

<?php

/**
 * TechDivision\Import\Product\Subjects\BunchSubject
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 *
 * PHP version 5
 *
 * @author    Tim Wagner <t.wagner@techdivision.com>
 * @copyright 2016 TechDivision GmbH <info@techdivision.com>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/techdivision/import-product
 * @link      http://www.techdivision.com
 */

namespace TechDivision\Import\Product\Subjects;

use TechDivision\Import\Product\Utils\MemberNames;
use TechDivision\Import\Product\Utils\RegistryKeys;
use TechDivision\Import\Product\Utils\VisibilityKeys;
use TechDivision\Import\Subjects\ExportableSubjectInterface;
use TechDivision\Import\Subjects\ExportableTrait;

/**
 * The subject implementation that handles the business logic to persist products.
 *
 * @author    Tim Wagner <t.wagner@techdivision.com>
 * @copyright 2016 TechDivision GmbH <info@techdivision.com>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/techdivision/import-product
 * @link      http://www.techdivision.com
 */
class BunchSubject extends AbstractProductSubject implements ExportableSubjectInterface
{

    /**
     * The trait that implements the export functionality.
     *
     * @var \TechDivision\Import\Subjects\ExportableTrait
     */
    use ExportableTrait;

    /**
     * The mapping for the SKU => visibility.
     *
     * @var array
     */
    protected $entityIdVisibilityIdMapping = array();

    /**
     * The array with the pre-loaded entity IDs.
     *
     * @var array
     */
    protected $preLoadedEntityIds = array();

    /**
     * Mappings for the table column => CSV column header.
     *
     * @var array
     */
    protected $headerStockMappings = array(
        'qty'                         => array('qty', 'float'),
        'min_qty'                     => array('out_of_stock_qty', 'float'),
        'use_config_min_qty'          => array('use_config_min_qty', 'int'),
        'is_qty_decimal'              => array('is_qty_decimal', 'int'),
        'backorders'                  => array('allow_backorders', 'int'),
        'use_config_backorders'       => array('use_config_backorders', 'int'),
        'min_sale_qty'                => array('min_cart_qty', 'float'),
        'use_config_min_sale_qty'     => array('use_config_min_sale_qty', 'int'),
        'max_sale_qty'                => array('max_cart_qty', 'float'),
        'use_config_max_sale_qty'     => array('use_config_max_sale_qty', 'int'),
        'is_in_stock'                 => array('is_in_stock', 'int'),
        'notify_stock_qty'            => array('notify_on_stock_below', 'float'),
        'use_config_notify_stock_qty' => array('use_config_notify_stock_qty', 'int'),
        'manage_stock'                => array('manage_stock', 'int'),
        'use_config_manage_stock'     => array('use_config_manage_stock', 'int'),
        'use_config_qty_increments'   => array('use_config_qty_increments', 'int'),
        'qty_increments'              => array('qty_increments', 'float'),
        'use_config_enable_qty_inc'   => array('use_config_enable_qty_inc', 'int'),
        'enable_qty_increments'       => array('enable_qty_increments', 'int'),
        'is_decimal_divided'          => array('is_decimal_divided', 'int'),
    );

    /**
     * The array with the available visibility keys.
     *
     * @var array
     */
    protected $availableVisibilities = array(
        'Not Visible Individually' => VisibilityKeys::VISIBILITY_NOT_VISIBLE,
        'Catalog'                  => VisibilityKeys::VISIBILITY_IN_CATALOG,
        'Search'                   => VisibilityKeys::VISIBILITY_IN_SEARCH,
        'Catalog, Search'          => VisibilityKeys::VISIBILITY_BOTH
    );

    /**
     * The category IDs the product is related with.
     *
     * @var array
     */
    protected $productCategoryIds = array();

    /**
     * The default callback mappings for the Magento standard product attributes.
     *
     * @var array
     */
    protected $defaultCallbackMappings = array(
        'visibility'           => array('import_product.callback.visibility'),
        'tax_class_id'         => array('import_product.callback.tax.class'),
        'bundle_price_type'    => array('import_product_bundle.callback.bundle.type'),
        'bundle_sku_type'      => array('import_product_bundle.callback.bundle.type'),
        'bundle_weight_type'   => array('import_product_bundle.callback.bundle.type'),
        'bundle_price_view'    => array('import_product_bundle.callback.bundle.price.view'),
        'bundle_shipment_type' => array('import_product_bundle.callback.bundle.shipment.type')
    );

    /**
     * The used URL keys.
     *
     * @var array
     */
    protected $usedUrlKeys = array();

    /**
     * The available entity types.
     *
     * @var array
     */
    protected $entityTypes = array();

    /**
     * Intializes the previously loaded global data for exactly one bunch.
     *
     * @param string $serial The serial of the actual import
     *
     * @return void
     */
    public function setUp($serial)
    {

        // load the status of the actual import
        $status = $this->getRegistryProcessor()->getAttribute($serial);

        // load the global data we've prepared initially
        $this->entityTypes = $status[RegistryKeys::GLOBAL_DATA][RegistryKeys::ENTITY_TYPES];

        // invoke the parent method
        parent::setUp($serial);
    }

    /**
     * Clean up the global data after importing the bunch.
     *
     * @param string $serial The serial of the actual import
     *
     * @return void
     */
    public function tearDown($serial)
    {

        // invoke the parent method
        parent::tearDown($serial);

        // load the registry processor
        $registryProcessor = $this->getRegistryProcessor();

        // update the status
        $registryProcessor->mergeAttributesRecursive(
            $serial,
            array(
                RegistryKeys::PRE_LOADED_ENTITY_IDS => $this->preLoadedEntityIds,
            )
        );
    }

    /**
     * Return's the default callback mappings.
     *
     * @return array The default callback mappings
     */
    public function getDefaultCallbackMappings()
    {
        return $this->defaultCallbackMappings;
    }

    /**
     * Return's the mappings for the table column => CSV column header.
     *
     * @return array The header stock mappings
     */
    public function getHeaderStockMappings()
    {
        return $this->headerStockMappings;
    }

    /**
     * Return's the visibility key for the passed visibility string.
     *
     * @param string $visibility The visibility string to return the key for
     *
     * @return integer The requested visibility key
     * @throws \Exception Is thrown, if the requested visibility is not available
     */
    public function getVisibilityIdByValue($visibility)
    {

        // query whether or not, the requested visibility is available
        if (isset($this->availableVisibilities[$visibility])) {
            // load the visibility ID, add the mapping and return the ID
            return $this->availableVisibilities[$visibility];
        }

        // throw an exception, if not
        throw new \Exception(
            $this->appendExceptionSuffix(
                sprintf('Found invalid visibility %s', $visibility)
            )
        );
    }

    /**
     * Add the entity ID => visibility mapping for the actual entity ID.
     *
     * @param string $visibility The visibility of the actual entity to map
     *
     * @return void
     */
    public function addEntityIdVisibilityIdMapping($visibility)
    {
        $this->entityIdVisibilityIdMapping[$this->getLastEntityId()] = $this->getVisibilityIdByValue($visibility);
    }

    /**
     * Return's the visibility for the passed entity ID, if it already has been mapped. The mapping will be created
     * by calling <code>\TechDivision\Import\Product\Subjects\BunchSubject::getVisibilityIdByValue</code> which will
     * be done by the <code>\TechDivision\Import\Product\Callbacks\VisibilityCallback</code>.
     *
     * @return integer The visibility ID
     * @throws \Exception Is thrown, if the entity ID has not been mapped
     * @see \TechDivision\Import\Product\Subjects\BunchSubject::getVisibilityIdByValue()
     */
    public function getEntityIdVisibilityIdMapping()

This method seems to be duplicated in your project.

    {

        // query whether or not the SKU has already been mapped to it's visibility
        if (isset($this->entityIdVisibilityIdMapping[$entityId = $this->getLastEntityId()])) {
            return $this->entityIdVisibilityIdMapping[$entityId];
        }

        // throw a new exception
        throw new \Exception(
            $this->appendExceptionSuffix(
                sprintf('Can\'t find visibility mapping for entity ID "%d"', $entityId)
            )
        );
    }

    /**
     * Add the passed category ID to the product's category list.
     *
     * @param integer $categoryId The category ID to add
     *
     * @return void
     */
    public function addProductCategoryId($categoryId)
    {
        $this->productCategoryIds[$this->getLastEntityId()][$categoryId] = $this->getLastEntityId();
    }

    /**
     * Pre-load the entity ID for the passed product.
     *
     * @param array $product The product to be pre-loaded
     *
     * @return void
     */
    public function preLoadEntityId(array $product)
    {
        $this->preLoadedEntityIds[$product[MemberNames::SKU]] = $product[MemberNames::ENTITY_ID];
    }

    /**
     * Return's the list with category IDs the product is related with.
     *
     * @return array The product's category IDs
     */
    public function getProductCategoryIds()
    {

        // initialize the array with the product's category IDs
        $categoryIds = array();

        // query whether or not category IDs are available for the actual product entity
        if (isset($this->productCategoryIds[$lastEntityId = $this->getLastEntityId()])) {
            $categoryIds = $this->productCategoryIds[$lastEntityId];
        }

        // return the array with the product's category IDs
        return $categoryIds;
    }

    /**
     * Return's the entity type for the configured entity type code.
     *
     * @return array The requested entity type
     * @throws \Exception Is thrown, if the requested entity type is not available
     */
    public function getEntityType()

This method seems to be duplicated in your project.

    {

        // query whether or not the entity type with the passed code is available
        if (isset($this->entityTypes[$entityTypeCode = $this->getEntityTypeCode()])) {
            return $this->entityTypes[$entityTypeCode];
        }

        // throw a new exception
        throw new \Exception(
            $this->appendExceptionSuffix(
                sprintf('Requested entity type "%s" is not available', $entityTypeCode)
            )
        );
    }

    /**
     * Return's TRUE, if the passed URL key varchar value IS related with the actual PK.
     *
     * @param array $productVarcharAttribute The varchar value to check
     *
     * @return boolean TRUE if the URL key is related, else FALSE
     */
    public function isUrlKeyOf(array $productVarcharAttribute)
    {
        return ($productVarcharAttribute[MemberNames::ENTITY_ID] === $this->getLastEntityId()) && ((integer) $productVarcharAttribute[MemberNames::STORE_ID] === $this->getRowStoreId());
    }
}