TechDivision\Import\Category\Subjects\BunchSubject

Complexity

Total Complexity

32

Size/Duplication

Total Lines	405
Duplicated Lines	8.89 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	getEavAttributeByIsUserDefined()	0	4	1
C	setUp()	0	42	7
A	getDisplayModeByValue()	18	18	2
A	getPageLayoutByValue()	18	18	2
A	castValueByBackendType()	0	21	4
A	getBackendTypes()	0	4	1
A	loadCategory()	0	4	1
A	loadCategoryDatetimeAttribute()	0	4	1
A	loadCategoryDecimalAttribute()	0	4	1
A	loadCategoryIntAttribute()	0	4	1
A	loadCategoryTextAttribute()	0	4	1
A	loadCategoryVarcharAttribute()	0	4	1
A	persistCategory()	0	4	1
A	persistCategoryVarcharAttribute()	0	4	1
A	persistCategoryIntAttribute()	0	4	1
A	persistCategoryDecimalAttribute()	0	4	1
A	persistCategoryDatetimeAttribute()	0	4	1
A	persistCategoryTextAttribute()	0	4	1
A	persistUrlRewrite()	0	4	1
A	deleteUrlRewrite()	0	4	1
A	deleteCategory()	0	4	1

<?php

/**
 * TechDivision\Import\Category\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-category
 * @link      http://www.techdivision.com
 */

namespace TechDivision\Import\Category\Subjects;

use TechDivision\Import\Category\Utils\DisplayModeKeys;
use TechDivision\Import\Subjects\ExportableTrait;
use TechDivision\Import\Subjects\ExportableSubjectInterface;
use TechDivision\Import\Category\Utils\MemberNames;
use TechDivision\Import\Category\Utils\PageLayoutKeys;

/**
 * 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-category
 * @link      http://www.techdivision.com
 */
class BunchSubject extends AbstractCategorySubject implements ExportableSubjectInterface
{

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

    /**
     * The mapping for the supported backend types (for the category entity) => persist methods.
     *
     * @var array
     */
    protected $backendTypes = array(
        'datetime' => array('persistCategoryDatetimeAttribute', 'loadCategoryDatetimeAttribute'),
        'decimal'  => array('persistCategoryDecimalAttribute', 'loadCategoryDecimalAttribute'),
        'int'      => array('persistCategoryIntAttribute', 'loadCategoryIntAttribute'),
        'text'     => array('persistCategoryTextAttribute', 'loadCategoryTextAttribute'),
        'varchar'  => array('persistCategoryVarcharAttribute', 'loadCategoryVarcharAttribute'),
        'image'    => array('persistCategoryVarcharAttribute', 'loadCategoryVarcharAttribute')
    );

    /**
     * The array with the available display mode keys.
     *
     * @var array
     */
    protected $availableDisplayModes = array(
        'Products only'             => DisplayModeKeys::DISPLAY_MODE_PRODUCTS_ONLY,
        'Static block only'         => DisplayModeKeys::DISPLAY_MODE_STATIC_BLOCK_ONLY,
        'Static block and products' => DisplayModeKeys::DISPLAY_MODE_BOTH
    );

    /**
     * The array with the available page layout keys.
     *
     * @var array
     */
    protected $availablePageLayouts = array(
        '1 column'                 => PageLayoutKeys::PAGE_LAYOUT_1_COLUMN,
        '2 columns with left bar'  => PageLayoutKeys::PAGE_LAYOUT_2_COLUMNS_LEFT,
        '2 columns with right bar' => PageLayoutKeys::PAGE_LAYOUT_2_COLUMNS_RIGHT,
        '3 columns'                => PageLayoutKeys::PAGE_LAYOUT_3_COLUMNS,
        'Empty'                    => PageLayoutKeys::PAGE_LAYOUT_EMPTY
    );

    /**
     * The default callback mappings for the Magento standard category attributes.
     *
     * @var array
     */
    protected $defaultCallbackMappings = array(
        'display_mode' => array('TechDivision\\Import\\Category\\Callbacks\\DisplayModeCallback'),
        'page_layout'  => array('TechDivision\\Import\\Category\\Callbacks\\PageLayoutCallback'),
    );

    /**
     * Return's an array with the available EAV attributes for the passed is user defined flag.
     *
     * @param integer $isUserDefined The flag itself
     *
     * @return array The array with the EAV attributes matching the passed flag
     */
    public function getEavAttributeByIsUserDefined($isUserDefined = 1)
    {
        return $this->getCategoryProcessor()->getEavAttributeByIsUserDefined($isUserDefined);
    }

    /**
     * Intializes the previously loaded global data for exactly one bunch.
     *
     * @return void
     * @see \Importer\Csv\Actions\ProductImportAction::prepare()
     */
    public function setUp()
    {

        // initialize the callback mappings with the default mappings
        $this->callbackMappings = array_merge($this->callbackMappings, $this->defaultCallbackMappings);

        // load the user defined attributes and add the callback mappings
        foreach ($this->getEavAttributeByIsUserDefined() as $eavAttribute) {
            // load attribute code and frontend input type
            $attributeCode = $eavAttribute[MemberNames::ATTRIBUTE_CODE];
            $frontendInput = $eavAttribute[MemberNames::FRONTEND_INPUT];

            // query whether or not the array for the mappings has been initialized
            if (!isset($this->callbackMappings[$attributeCode])) {
                $this->callbackMappings[$attributeCode] = array();
            }

            // set the appropriate callback mapping for the attributes input type
            if (isset($this->defaultFrontendInputCallbackMapping[$frontendInput])) {
                $this->callbackMappings[$attributeCode][] = $this->defaultFrontendInputCallbackMapping[$frontendInput];

The property defaultFrontendInputCallbackMapping does not exist. Did you maybe forget to declare it?

            }
        }

        // merge the callback mappings the the one from the configuration file
        foreach ($this->getConfiguration()->getCallbacks() as $callbackMappings) {
            foreach ($callbackMappings as $attributeCode => $mappings) {
                // write a log message, that default callback configuration will
                // be overwritten with the one from the configuration file
                if (isset($this->callbackMappings[$attributeCode])) {
                    $this->getSystemLogger()->notice(
                        sprintf('Now override callback mappings for attribute %s with values found in configuration file', $attributeCode)
                    );
                }

                // override the attributes callbacks
                $this->callbackMappings[$attributeCode] = $mappings;
            }
        }

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

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

This method seems to be duplicated in your project.

    {

        // query whether or not, the requested display mode is available
        if (isset($this->availableDisplayModes[$displayMode])) {
            return $this->availableDisplayModes[$displayMode];
        }

        // throw an exception, if not
        throw new \Exception(
            sprintf(
                'Found invalid display mode %s in file %s on line %d',
                $visibility,
                $this->getFilename(),
                $this->getLineNumber()
            )
        );
    }

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

This method seems to be duplicated in your project.

    {

        // query whether or not, the requested display mode is available
        if (isset($this->availablePageLayouts[$pageLayout])) {
            return $this->availablePageLayouts[$pageLayout];
        }

        // throw an exception, if not
        throw new \Exception(
            sprintf(
                'Found invalid page layout %s in file %s on line %d',
                $visibility,
                $this->getFilename(),
                $this->getLineNumber()
            )
        );
    }

    /**
     * Cast's the passed value based on the backend type information.
     *
     * @param string $backendType The backend type to cast to
     * @param mixed  $value       The value to be casted
     *
     * @return mixed The casted value
     */
    public function castValueByBackendType($backendType, $value)
    {

        // cast the value to a valid timestamp
        if ($backendType === 'datetime') {
            return \DateTime::createFromFormat($this->getSourceDateFormat(), $value)->format('Y-m-d H:i:s');
        }

        // cast the value to a float value
        if ($backendType === 'float') {
            return (float) $value;
        }

        // cast the value to an integer
        if ($backendType === 'int') {
            return (int) $value;
        }

        // we don't need to cast strings
        return $value;
    }

    /**
     * Return's mapping for the supported backend types (for the product entity) => persist methods.
     *
     * @return array The mapping for the supported backend types
     */
    public function getBackendTypes()
    {
        return $this->backendTypes;
    }

    /**
     * Return's the category with the passed ID.
     *
     * @param string $id The ID of the category to return
     *
     * @return array The category
     */
    public function loadCategory($id)
    {
        return $this->getCategoryProcessor()->loadCategory($id);
    }

    /**
     * Load's and return's the datetime attribute with the passed entity/attribute/store ID.
     *
     * @param integer $entityId    The entity ID of the attribute
     * @param integer $attributeId The attribute ID of the attribute
     * @param integer $storeId     The store ID of the attribute
     *
     * @return array|null The datetime attribute
     */
    public function loadCategoryDatetimeAttribute($entityId, $attributeId, $storeId)
    {
        return $this->getCategoryProcessor()->loadCategoryDatetimeAttribute($entityId, $attributeId, $storeId);
    }

    /**
     * Load's and return's the decimal attribute with the passed entity/attribute/store ID.
     *
     * @param integer $entityId    The entity ID of the attribute
     * @param integer $attributeId The attribute ID of the attribute
     * @param integer $storeId     The store ID of the attribute
     *
     * @return array|null The decimal attribute
     */
    public function loadCategoryDecimalAttribute($entityId, $attributeId, $storeId)
    {
        return $this->getCategoryProcessor()->loadCategoryDecimalAttribute($entityId, $attributeId, $storeId);
    }

    /**
     * Load's and return's the integer attribute with the passed entity/attribute/store ID.
     *
     * @param integer $entityId    The entity ID of the attribute
     * @param integer $attributeId The attribute ID of the attribute
     * @param integer $storeId     The store ID of the attribute
     *
     * @return array|null The integer attribute
     */
    public function loadCategoryIntAttribute($entityId, $attributeId, $storeId)
    {
        return $this->getCategoryProcessor()->loadCategoryIntAttribute($entityId, $attributeId, $storeId);
    }

    /**
     * Load's and return's the text attribute with the passed entity/attribute/store ID.
     *
     * @param integer $entityId    The entity ID of the attribute
     * @param integer $attributeId The attribute ID of the attribute
     * @param integer $storeId     The store ID of the attribute
     *
     * @return array|null The text attribute
     */
    public function loadCategoryTextAttribute($entityId, $attributeId, $storeId)
    {
        return $this->getCategoryProcessor()->loadCategoryTextAttribute($entityId, $attributeId, $storeId);
    }

    /**
     * Load's and return's the varchar attribute with the passed entity/attribute/store ID.
     *
     * @param integer $entityId    The entity ID of the attribute
     * @param integer $attributeId The attribute ID of the attribute
     * @param integer $storeId     The store ID of the attribute
     *
     * @return array|null The varchar attribute
     */
    public function loadCategoryVarcharAttribute($entityId, $attributeId, $storeId)
    {
        return $this->getCategoryProcessor()->loadCategoryVarcharAttribute($entityId, $attributeId, $storeId);
    }

    /**
     * Persist's the passed category data and return's the ID.
     *
     * @param array $category The category data to persist
     *
     * @return string The ID of the persisted entity
     */
    public function persistCategory($category)
    {
        return $this->getCategoryProcessor()->persistCategory($category);
    }

    /**
     * Persist's the passed category varchar attribute.
     *
     * @param array $attribute The attribute to persist
     *
     * @return void
     */
    public function persistCategoryVarcharAttribute($attribute)
    {
        $this->getCategoryProcessor()->persistCategoryVarcharAttribute($attribute);
    }

    /**
     * Persist's the passed category integer attribute.
     *
     * @param array $attribute The attribute to persist
     *
     * @return void
     */
    public function persistCategoryIntAttribute($attribute)
    {
        $this->getCategoryProcessor()->persistCategoryIntAttribute($attribute);
    }

    /**
     * Persist's the passed category decimal attribute.
     *
     * @param array $attribute The attribute to persist
     *
     * @return void
     */
    public function persistCategoryDecimalAttribute($attribute)
    {
        $this->getCategoryProcessor()->persistCategoryDecimalAttribute($attribute);
    }

    /**
     * Persist's the passed category datetime attribute.
     *
     * @param array $attribute The attribute to persist
     *
     * @return void
     */
    public function persistCategoryDatetimeAttribute($attribute)
    {
        $this->getCategoryProcessor()->persistCategoryDatetimeAttribute($attribute);
    }

    /**
     * Persist's the passed category text attribute.
     *
     * @param array $attribute The attribute to persist
     *
     * @return void
     */
    public function persistCategoryTextAttribute($attribute)
    {
        $this->getCategoryProcessor()->persistCategoryTextAttribute($attribute);
    }

    /**
     * Persist's the URL rewrite with the passed data.
     *
     * @param array $row The URL rewrite to persist
     *
     * @return string The ID of the persisted entity
     */
    public function persistUrlRewrite($row)
    {
        $this->getCategoryProcessor()->persistUrlRewrite($row);
    }

    /**
     * Delete's the URL rewrite(s) with the passed attributes.
     *
     * @param array       $row  The attributes of the entity to delete
     * @param string|null $name The name of the prepared statement that has to be executed
     *
     * @return void
     */
    public function deleteUrlRewrite($row, $name = null)
    {
        $this->getCategoryProcessor()->deleteUrlRewrite($row, $name);
    }

    /**
     * Delete's the entity with the passed attributes.
     *
     * @param array       $row  The attributes of the entity to delete
     * @param string|null $name The name of the prepared statement that has to be executed
     *
     * @return void
     */
    public function deleteCategory($row, $name = null)
    {
        $this->getCategoryProcessor()->deleteCategory($row, $name);
    }
}