Import - Code Metrics - Inspection of "adding order into cat. tree on the backend product..." - DevGroup-ru/dotplant2 - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — action_getCatTree_order ( 77944b )

unknown

created 2016-01-20 06:59 UTC

Import F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	528
Duplicated Lines	2.65 %

Coupling/Cohesion

Components	1
Dependencies	20

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
wmc	96
lcom	1
cbo	20
dl	14
loc	528
rs	1.5789
c	1
b	1
f	0

11 Methods

Rating	Name	Duplication	Size	Complexity
	getData()	0	1	?
	setData()	0	1	?
A	getObject()	0	4	1
A	__construct()	0	14	4
F	save()	0	143	25
B	createInstance()	0	22	6
A	getFields()	0	12	2
A	getProperties()	0	12	3
B	getAllFields()	14	30	6
F	processExport()	0	145	35
D	processImport()	0	72	14

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Import often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Import, and based on these observations, apply Extract Interface, too.

<?php

namespace app\modules\data\components;

use app\models\Object;
use app\models\ObjectPropertyGroup;
use app\models\ObjectStaticValues;
use app\modules\shop\models\Product;
use app\models\Property;
use app\models\PropertyGroup;
use app\models\PropertyStaticValues;
use devgroup\TagDependencyHelper\ActiveRecordHelper;
use Yii;
use yii\base\Component;
use yii\base\InvalidParamException;
use yii\db\ActiveQuery;
use yii\db\ActiveRecord;
use yii\db\Expression;
use yii\helpers\ArrayHelper;

abstract class Import extends Component
{
    protected $object;
    protected $properties = null;
    public $filename;
    public $addPropertyGroups = [];
    public $createIfNotExists = false;
    public $multipleValuesDelimiter = '|';
    public $additionalFields = [];

    /*
     * Export method
     */
    abstract public function getData($header, $data);

    /*
     * Import method
     */
    abstract public function setData();


    /**
     * @param array $config
     * @return ImportCsv
     * @throws \Exception
     */
    public static function createInstance($config)
    {
        if (isset($config['type'])) {
            $type = $config['type'];
            unset($config['type']);

            switch ($type) {
                case 'csv':
                    return new ImportCsv($config);
                case 'excelCsv':
                    return new ImportExcelCsv($config);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
                case 'xls':
                    return new ImportXlsx(array_merge(['fileType' => 'xls'], $config));
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
                case 'xlsx':
                    return new ImportXlsx(array_merge(['fileType' => 'xlsx'], $config));
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
                default:
                    throw new \Exception('Unsupported type');
            }
        } else {
            throw new InvalidParamException('Parameter \'type\' is not set');
        }
    }

    /**
     * @param $objectId
     * @return array
     */
    public static function getFields($objectId)
    {
        $fields = [];
        $object = Object::findById($objectId);
        if ($object) {
            $fields['object'] = array_diff((new $object->object_class)->attributes(), ['id']);
            $fields['object'] = array_combine($fields['object'], $fields['object']);
            $fields['property'] = ArrayHelper::getColumn(static::getProperties($objectId), 'key');
            $fields['additionalFields'] = [];
        }
        return $fields;
    }

    /**
     * @param $objectId
     * @return array
     */
    protected static function getProperties($objectId)
    {
        $properties = [];
        $groups = PropertyGroup::getForObjectId($objectId);
        foreach ($groups as $group) {
            $props = Property::getForGroupId($group->id);
            foreach ($props as $prop) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                $properties[] = $prop;
            }
        }
        return $properties;
    }

    /**
     * @return Object

     */
    public function getObject()
    {
        return $this->object;
    }

    /**
     * @param array $config
     */
    public function __construct($config = [])
    {
        if (!isset($config['object'])) {
            throw new InvalidParamException('Parameters \'object\' is not set');
        }
        $this->object = $config['object'];
        if (is_numeric($this->object)) {
            $this->object = Object::findById($this->object);
        } elseif (!($this->object instanceof Object)) {
            throw new InvalidParamException('Parameter "object" not Object or numeric');
        }
        unset($config['object']);
        parent::__construct($config);
    }

    /**
     * @param $objectId
     * @param $object
     * @param array $objectFields
     * @param array $properties
     * @param array $propertiesFields
     * @param array $row
     * @param array $titleFields
     * @throws \Exception
     */
    protected function save($objectId, $object, $objectFields = [], $properties = [], $propertiesFields = [], $row=[], $titleFields=[], $columnsCount = null)

    {
        if ($columnsCount === null) {
            $columnsCount = count($titleFields);
        }
        try {
            $rowFields = array_combine(array_keys($titleFields), array_slice($row, 0, $columnsCount));
        } catch(\Exception $e) {
            echo "title fields: ";
            var_dump(array_keys($titleFields));

            echo "\n\nRow:";
            var_dump($row);
            echo "\n\n";
            throw $e;
        }

        $class = $this->object->object_class;
        if ($objectId > 0) {
            /** @var ActiveRecord $objectModel */
            $objectModel = $class::findOne($objectId);
            if (!is_object($objectModel)) {
                if ($this->createIfNotExists === true) {
                    $objectModel = new $class;
                    $objectModel->id = $objectId;
                } else {
                    return;
                }
            }
            $objectData = [];
            foreach ($objectFields as $field) {
                if (isset($object[$field])) {
                    $objectData[$field] = $object[$field];
                }
            }
        } else {
            /** @var ActiveRecord $objectModel */
            $objectModel = new $class;
            $objectModel->loadDefaultValues();
            $objectData = $object;
        }
        if ($objectModel) {

            if ($objectModel instanceof ImportableInterface) {
                $objectModel->processImportBeforeSave($rowFields, $this->multipleValuesDelimiter, $this->additionalFields);

            }

            if ($objectModel->save()) {

                // add PropertyGroup to object
                if (!is_array($this->addPropertyGroups)) {
                    $this->addPropertyGroups = [];
                }
                foreach ($this->addPropertyGroups as $propertyGroupId) {
                    $model = new ObjectPropertyGroup();
                    $model->object_id = $this->object->id;
                    $model->object_model_id = $objectModel->id;
                    $model->property_group_id = $propertyGroupId;
                    $model->save();
                }
                if (count($this->addPropertyGroups) > 0) {
                    $objectModel->updatePropertyGroupsInformation();
                }

                $propertiesData = [];
                $objectModel->getPropertyGroups();

                foreach ($propertiesFields as $propertyId => $field) {
                    if (isset($properties[$field['key']])) {
                        $value = $properties[$field['key']];

                        if (isset($field['processValuesAs'])) {
                            // it is PSV in text
                            // we should convert it to ids
                            $staticValues = PropertyStaticValues::getValuesForPropertyId($propertyId);

                            $representationConversions = [
                                // from -> to
                                'text' => 'name',
                                'value' => 'value',
                                'id' => 'id',
                            ];
                            $attributeToGet = $representationConversions[$field['processValuesAs']];
                            $ids = [];
                            foreach ($value as $initial) {
                                $original = $initial;
                                $initial = mb_strtolower(trim($original));
                                $added = false;
                                foreach ($staticValues as $static) {
                                    if (mb_strtolower(trim($static[$attributeToGet])) === $initial) {
                                        $ids [] = $static['id'];
                                        $added = true;
                                    }
                                }
                                if (!$added) {
                                    // create PSV!
                                    $model = new PropertyStaticValues();
                                    $model->property_id = $propertyId;
                                    $model->name = $model->value = $model->slug = $original;
                                    $model->sort_order = 0;
                                    $model->title_append = '';
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                                    if ($model->save()) {
                                        $ids[] = $model->id;
                                    }

                                    //flush cache!
                                    unset(PropertyStaticValues::$identity_map_by_property_id[$propertyId]);

                                    \yii\caching\TagDependency::invalidate(
                                        Yii::$app->cache,
                                        [
                                            \devgroup\TagDependencyHelper\ActiveRecordHelper::getObjectTag(Property::className(), $propertyId)

                                        ]
                                    );
                                }
                            }
                            $value = $ids;
                        }

                        $propertiesData[$field['key']] = $value;
                    }
                }

                if (!empty($propertiesData)) {

                    $objectModel->saveProperties(
                        [
                            "Properties_{$objectModel->formName()}_{$objectModel->id}" => $propertiesData
                        ]
                    );
                }

                if ($objectModel instanceof ImportableInterface) {
                    $objectModel->processImportAfterSave($rowFields, $this->multipleValuesDelimiter, $this->additionalFields);

                }

                if ($objectModel->hasMethod('invalidateTags')) {
                    $objectModel->invalidateTags();
                }
            } else {
                throw new \Exception('Cannot save object: ' . var_export($objectModel->errors, true) . var_export($objectData, true) . var_export($objectModel->getAttributes(), true));

            }
        }
    }

    /**
     * @param array $exportFields
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return array

     */
    public function getAllFields($fields = [])
    {
        $result = [];

        $fields_object = isset($fields['object']) ? $fields['object'] : [];
        $fields_property = isset($fields['property']) ? $fields['property'] : [];
        $fields_additional = isset($fields['additionalFields']) ? $fields['additionalFields'] : [];

        $result['fields_object'] = $data_header = array_merge($fields_object, ['internal_id']);

        $result['fields_property'] = array_filter($fields_property, function($input) use (&$data_header) {
            if (1 == $input['enabled']) {
                $data_header[] = $input['key'];
                return true;
            }
            return false;
        });

        $result['fields_additional'] = array_filter($fields_additional, function($input) use (&$data_header) {
            if (1 == $input['enabled']) {
                $data_header[] = $input['key'];
                return true;
            }
            return false;
        });

        $result['fields_header'] = $data_header;

        return $result;
    }

    /**
     * @param $exportFields
     * @param array $conditions
     * @param int $batchSize
     * @return bool
     * @throws \Exception
     */
    public function processExport($exportFields = [], $conditions = [], $batchSize = 100)
    {
        $fields = $this->getAllFields($exportFields);

        $class = $this->object->object_class;
        /** @var $select ActiveQuery */
        $select = $class::find();

        $representationConversions = [
            'text' => 'name',
            'value' => 'value',
            'id' => 'psv_id',
        ];

        if (
            isset($conditions['category']) &&
            is_array($conditions['category']) &&
            $this->object->id == Object::getForClass(Product::className())->id
        ) {
            foreach ($conditions['category'] as $condition) {
                $joinTableName = 'Category'.$condition['value'];

                $select->innerJoin(
                    "{{%product_category}} " . $joinTableName,
                    "$joinTableName.object_model_id = product.id"
                );
                $select->andWhere(
                    new Expression(
                        '`' . $joinTableName . '`.`category_id` = "'.$condition['value'].'"'
                    )
                );
            }
        }

        if (isset($conditions['field']) && is_array($conditions['field'])) {
            foreach ($conditions['field'] as $condition) {
                $conditionOptions = [$condition['operators'], $condition['value'], $condition['option']];
                if ($condition['comparison'] == 'AND') {
                    $select->andWhere($conditionOptions);
                } elseif ($condition['comparison'] == 'OR') {
                    $select->orWhere($conditionOptions);
                }
            }
        }
        if (isset($conditions['property']) && is_array($conditions['property'])) {
            foreach ($conditions['property'] as $condition) {
                $property = Property::findById($condition['value']);

                if ($property && isset($condition['option']) &&  !empty($condition['option'])) {
                    if ($property->is_eav) {
                        $joinTableName = 'EAVJoinTable'.$property->id;

                        $select->innerJoin(
                            $this->object->eav_table_name . " " . $joinTableName,
                            "$joinTableName.object_model_id = " .
                            Yii::$app->db->quoteTableName($this->object->object_table_name) . ".id "
                        );
                        $select->andWhere(
                            new Expression(
                                '`' . $joinTableName . '`.`value` '.$condition['operators'].' "'.$condition['option'].'" AND `' .

                                $joinTableName . '`.`key` = "'. $property->key.'"'
                            )
                        );
                    } elseif ($property->has_static_values) {
                        $joinTableName = 'OSVJoinTable'.$property->id;
                        $propertyStaticValue = PropertyStaticValues::find()->where(['value'=>$condition['option']])->one();


                        if ($propertyStaticValue) {
                            $select->innerJoin(
                                ObjectStaticValues::tableName() . " " . $joinTableName,
                                "$joinTableName.object_id = " . intval($this->object->id) .
                                " AND $joinTableName.object_model_id = " .
                                Yii::$app->db->quoteTableName($this->object->object_table_name) . ".id "
                            );

                            $select->andWhere(
                                new Expression(
                                    '`' . $joinTableName . '`.`property_static_value_id` ="'.$propertyStaticValue->id.'"'

                                )
                            );
                        }
                    } else {
                        throw new \Exception("Wrong property type for ".$property->id);
                    }
                }
            }
        }

        $data = [];
        $batchSize = intval($batchSize) <= 0 ? 100 : intval($batchSize);
        foreach ($select->each($batchSize) as $object) {
            $row = [];

            foreach ($fields['fields_object'] as $field) {
                if ('internal_id' === $field) {
                    $row[] = $object->id;
                } else {
                    $row[] = isset($object->$field) ? $object->$field : '';
                }
            }

            foreach ($fields['fields_property'] as $field_id => $field) {
                $value = $object->getPropertyValuesByPropertyId($field_id);

                if (!is_object($value)) {
                    $value = '';
                } elseif (count($value->values) > 1 && isset($fields_property[$field_id])) {
                    if (isset($fields_property[$field_id]['processValuesAs'])) {
                        $attributeToGet = $representationConversions[$fields_property[$field_id]['processValuesAs']];
                        $newValues = [];
                        foreach ($value->values as $val) {
                            $newValues[] = $val[$attributeToGet];
                        }
                        $value = implode($this->multipleValuesDelimiter, $newValues);
                    }
                } else {
                    $value = (string) $value;
                }

                $row[] = $value;
            }

            if (!empty($fields['fields_additional']) && $object->hasMethod('getAdditionalFields')) {
                $fieldsFromModel = $object->getAdditionalFields($fields['fields_additional']);
                foreach ($fields['fields_additional'] as $key => $configuration) {
                    if (!isset($fieldsFromModel[$key])) {
                        $fieldsFromModel[$key] = '';
                    }

                    if (!empty($fieldsFromModel[$key])) {
                        $value = (array)$fieldsFromModel[$key];
                        $row[] = implode($this->multipleValuesDelimiter, $value);
                    } else {
                        $row[] = '';
                    }
                }
            }

            $data[] = $row;
        }

        unset($value, $row, $object, $select, $class);

        return $this->getData($fields['fields_header'], $data);
    }

    /**
     * @param array $importFields
     * @return bool
     * @throws \Exception
     * @throws \yii\db\Exception
     */
    public function processImport($importFields = [])
    {
        $fields = $this->getAllFields($importFields);
        $data = $this->setData();

        $objectFields = static::getFields($this->object->id);
        $objAttributes = $objectFields['object'];
        $propAttributes = isset($objectFields['property']) ? $objectFields['property'] : [];

        $titleFields = array_filter(
            array_shift($data),
            function ($value) {
                return !empty($value);
            }
        );
        $titleFields = array_intersect_key(array_flip($titleFields), array_flip($fields['fields_header']));

        $transaction = \Yii::$app->db->beginTransaction();
        $columnsCount = count($titleFields);
        try {
            foreach ($data as $row) {
                $objData = [];
                $propData = [];
                foreach ($objAttributes as $attribute) {
                    if (isset($titleFields[$attribute])) {
                        $objData[$attribute] = $row[$titleFields[$attribute]];
                    }
                }
                foreach ($propAttributes as $attribute) {
                    if (!(isset($titleFields[$attribute]))) {
                        continue;
                    }
                    $propValue = $row[$titleFields[$attribute]];
                    if (!empty($this->multipleValuesDelimiter)) {
                        if (strpos($propValue, $this->multipleValuesDelimiter) > 0) {
                            $values = explode($this->multipleValuesDelimiter, $propValue);
                        } elseif (strpos($this->multipleValuesDelimiter, '/') === 0) {
                            $values = preg_split($this->multipleValuesDelimiter, $propValue);
                        } else {
                            $values = [$propValue];
                        }
                        $propValue = [];
                        foreach ($values as $value) {
                            $value = trim($value);
                            if (!empty($value)) {
                                $propValue[] = $value;
                            }
                        }
                    }
                    $propData[$attribute] = $propValue;
                }

                $objectId = isset($titleFields['internal_id']) ? $row[$titleFields['internal_id']] : 0;
                $this->save(
                    $objectId,
                    $objData,
                    $fields['fields_object'],
                    $propData,
                    $fields['fields_property'],
                    $row,
                    $titleFields,
                    $columnsCount
                );
            }
        } catch (\Exception $exception) {
            $transaction->rollBack();
            throw $exception;
        }
        $transaction->commit();

        return true;
    }
}


1			<?php
2
3			namespace app\modules\data\components;
4
5			use app\models\Object;
6			use app\models\ObjectPropertyGroup;
7			use app\models\ObjectStaticValues;
8			use app\modules\shop\models\Product;
9			use app\models\Property;
10			use app\models\PropertyGroup;
11			use app\models\PropertyStaticValues;
12			use devgroup\TagDependencyHelper\ActiveRecordHelper;
13			use Yii;
14			use yii\base\Component;
15			use yii\base\InvalidParamException;
16			use yii\db\ActiveQuery;
17			use yii\db\ActiveRecord;
18			use yii\db\Expression;
19			use yii\helpers\ArrayHelper;
20
21			abstract class Import extends Component
22			{
23			protected $object;
24			protected $properties = null;
25			public $filename;
26			public $addPropertyGroups = [];
27			public $createIfNotExists = false;
28			public $multipleValuesDelimiter = '\|';
29			public $additionalFields = [];
30
31			/*
32			* Export method
33			*/
34			abstract public function getData($header, $data);
			0 ignored issues – show Documentation introduced 2015-12-02 18:30 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
35			/*
36			* Import method
37			*/
38			abstract public function setData();
			0 ignored issues – show Documentation introduced 2015-12-02 18:30 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...

DevGroup-ru / dotplant2

GitHub Access Token became invalid