exchange\classes\ExchangeBase

Complexity

Total Complexity

28

Size/Duplication

Total Lines	273
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	1

Importance

Changes	8
Bugs	1	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	__clone()	0	3	1
A	getInstance()	0	8	2
A	__get()	0	4	1
B	insertBatch()	0	22	4
B	insertPropertiesData()	0	56	6
A	setXml()	0	4	1
A	updateBatch()	0	20	3
A	_updateBatchGroup()	0	10	2
A	_updatePerOne()	0	17	4
A	getStats()	0	4	1
A	import()	0	9	2
	import_()	0	1	?

<?php

namespace exchange\classes;

use CI_DB_active_record;
use CI_DB_result;
use Exception;
use MY_Controller;
use SimpleXMLElement;
use SPropertyValue;
use SPropertyValueQuery;

/**
 * Base class for import/export
 *
 * each class that extends ExchangeBase can

Doc comment long description must start with a capital letter

 * request its properties from db and xml
 *
 * @author kolia
 * @property CI_DB_active_record $db
 */
abstract class ExchangeBase
{

Opening brace of a class must be on the same line as the definition

    /**
     * "multisingleton"
     * @var array
     */
    protected static $instances = [];

    /**
     *
     * @var type
     */
    protected $db;

    /**
     *
     * @var ExchangeDataLoad
     */
    protected $dataLoad;

    /**
     *
     * @var SimpleXMLElement
     */
    protected $importData;

    /**
     * Current locale
     * @var string
     */
    protected $locale;

    /**
     *
     * @var SimpleXMLElement
     */
    protected $xml;

    /**
     * Storing results about queries
     * @var array
     */
    public static $stats = [];

    private function __construct() {

Something seems to be off here. Are you sure you want to declare the constructor as private, and the class as abstract?

        $this->dataLoad = ExchangeDataLoad::getInstance();
        $this->locale = MY_Controller::getCurrentLocale();
        $ci = &get_instance();
        $this->db = $ci->db;
    }

    private function __clone() {

    }

    /**
     *
     * @return Properties|Products
     */
    public static function getInstance() {

        $class = get_called_class();
        if (!isset(self::$instances[$class])) {
            self::$instances[$class] = new $class;

Instantiating objects should always be done with parentheses.

        }
        return self::$instances[$class];
    }

    public function __get($name) {

        return $this->dataLoad->$name;
    }

    /**
     * Alias for CI insert_batch
     * @param string $tableName
     * @param array $data
     * @throws Exception

Comment missing or not on the next line for @throws tag in function comment

     */
    protected function insertBatch($tableName, $data) {

        if (FALSE == (count($data) > 0)) {
            return;
        }

        foreach ($data as $value) {
            $this->db->set($value)->insert($tableName);
        }

        $error = $this->db->_error_message();

        if (!empty($error)) {
            throw new Exception("Error on inserting into `{$tableName}`: " . $error);
        }
        // gathering statistics
        ExchangeBase::$stats[] = [

As per coding style, self should be used for accessing local static members.

                                  'query type'    => 'insert',
                                  'table name'    => $tableName,
                                  'affected rows' => count($data),
                                 ];
    }

    /**
     * Alias for CI insert_batch
     * @param string $tableName
     * @param array $data
     * @throws Exception

Comment missing or not on the next line for @throws tag in function comment

     * @return bool|void

Consider making the return type a bit more specific; maybe use false|null.

     */
    protected function insertPropertiesData($tableName, $data) {

        if (FALSE == (count($data) > 0)) {
            return false;
        }

        foreach ($data as $value) {

            $property_value = SPropertyValueQuery::create()
                ->useSPropertyValueI18nQuery()
                ->filterByLocale($value['locale'])
                ->filterByValue($value['value'])
                ->endUse()
                ->findOneByPropertyId($value['property_id']);

            if (!$property_value) {

                $property_value = new SPropertyValue();
                $property_value->setPropertyId($value['property_id']);
                $property_value->setLocale($value['locale']);
                $property_value->setValue($value['value']);
                $property_value->save();

            }

            $this->db->set($value)->insert($tableName);

            $import_data = [
                            'property_id' => $value['property_id'],
                            'product_id'  => $value['product_id'],
                            'value_id'    => $property_value->getId(),
                           ];

            /** @var CI_DB_result $test */
            $test = $this->db->get_where('shop_product_properties_data', $import_data);

            if ($test->num_rows() > 0) {
                return false;
            }

            $this->db->insert('shop_product_properties_data', $import_data);

        }

        $error = $this->db->_error_message();

        if (!empty($error)) {
            throw new Exception("Error on inserting into `{$tableName}`: " . $error);
        }
        // gathering statistics
        ExchangeBase::$stats[] = [

As per coding style, self should be used for accessing local static members.

                                  'query type'    => 'insert',
                                  'table name'    => $tableName,
                                  'affected rows' => count($data),
                                 ];
    }

    public function setXml(SimpleXMLElement $xml) {

        $this->xml = $xml;
    }

    /**
     * Alias for CI update_batch
     * @param string $tableName
     * @param array $data
     * @param string $keyToCompare
     * @throws \Exception

Comment missing or not on the next line for @throws tag in function comment

     */
    protected function updateBatch($tableName, array $data, $keyToCompare) {

        if (FALSE == (count($data) > 0)) {
            return;
        }

        if ('shop_product_categories' == $tableName) {
            return;
        }

        //        $this->_updateBatchGroup($tableName, $data, $keyToComare); // error when more than 1 language
        $this->_updatePerOne($tableName, $data, $keyToCompare);

        // gathering statistics
        ExchangeBase::$stats[] = [

As per coding style, self should be used for accessing local static members.

                                  'query type'    => 'update',
                                  'table name'    => $tableName,
                                  'affected rows' => count($data),
                                 ];
    }

    /**
     *
     * @param string $tableName
     * @param array $data
     * @param string $keyToComare
     * @throws Exception

Comment missing or not on the next line for @throws tag in function comment

     */
    public function _updateBatchGroup($tableName, array $data, $keyToComare) {

        $this->db->update_batch($tableName, $data, $keyToComare);

        $error = $this->db->_error_message();

        if (!empty($error)) {
            throw new Exception("Error on updating `{$tableName}`: " . $error);
        }
    }

    /**
     *
     * @param string $tableName
     * @param array $data
     * @param string $keyToCompare
     * @throws Exception

Comment missing or not on the next line for @throws tag in function comment

     */
    public function _updatePerOne($tableName, array $data, $keyToCompare) {

        foreach ($data as $rowData) {
            $this->db->update($tableName, $rowData, [$keyToCompare => $rowData[$keyToCompare]], 1);

            $error = $this->db->_error_message();
            if (empty($error)) {
                continue;
            }

            log_message('error', sprintf("DB error: '%s'", $error));

            if (config_item('update:failOnError') == true) {
                throw new Exception("Error on updating `{$tableName}`: " . $error);
            }
        }
    }

    /**
     * Return statistic
     * @return array
     */
    public function getStats() {

        return $this->stats;
    }

    /**
     * Sets the data for import, starts import
     * @param SimpleXMLElement $importData
     */
    public function import(SimpleXMLElement $importData) {

        if (!count($importData) > 0) {
            return;
        }
        $this->importData = $importData;
        $this->import_();
        return;
    }

    /**
     * Runs the import process
     */
    abstract protected function import_();

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.

}