Migrations\Parser\Object

Complexity

Total Complexity

42

Size/Duplication

Total Lines	171
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	3
Bugs	2	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
B	parse()	0	18	5
C	parseData()	0	58	14
D	setModel()	0	83	23

<?php

/**
 * Pareser object
 *
 * @author Alexey Krupskiy <admin@inji.ru>
 * @link http://inji.ru/
 * @copyright 2015 Alexey Krupskiy
 * @license https://github.com/injitools/cms-Inji/blob/master/LICENSE
 */

namespace Migrations\Parser;

class Object extends \Object
{
    public $object;
    public $parentObject;
    public $parentModel;
    public $parentParam;
    public $data;

    public function parse($preset = [])
    {
        $ids = [];
        if (!\Tools::isAssoc($this->data)) {
            foreach ($this->data as &$data) {
                $id = $this->parseData($data, $preset);
                if ($id) {
                    $ids[] = $id;
                }
            }
        } else {
            $id = $this->parseData($this->data, $preset);
            if ($id) {
                $ids[] = $id;
            }
        }
        return $ids;
    }

    private function parseData($data, $preset)
    {
        $model = $this->setModel($data);
        if ($model) {
            foreach ($preset as $col => $value) {
                $model->{$col} = $value;
            }

            $walked = [];
            foreach ($this->object->params as $param) {
                if ($model && $param->type && $param->type != 'item_key') {
                    if ($param->type == 'object') {
                        $object = \Migrations\Migration\Object::get($param->value);
                        $parser = new \Migrations\Parser\Object;
                        $parser->data = &$data[$param->code];
                        $parser->object = $object;
                        $parser->parentObject = $this;
                        $parser->parentModel = $model;
                        $parser->walker = $this->walker;

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

                        $parser->parse();
                    } else {
                        if ($param->type == 'custom') {
                            $parserName = $param->value;
                        } else {
                            $parserName = '\Migrations\Parser\Object\\' . ucfirst($param->type);
                        }
                        if (!in_array($parserName, ['\Migrations\Parser\Object\ObjectLink','Exchange1c\Parser\Item\Images', '\Migrations\Parser\Object\Value', '\Migrations\Parser\Object\Relation', '\Migrations\Parser\Object\ParamsList'])) {
                            var_dump($parserName);

var_dump($parserName); looks like debug code. Are you sure you do not want to remove it? This might expose sensitive data.

                            exit();

The method parseData() contains an exit expression.

                        }
                        $parser = new $parserName;
                        $parser->data = &$data[$param->code];
                        $parser->param = $param;
                        $parser->model = $model;
                        $parser->object = $this;
                        $parser->parse();
                    }
                }
                $walked[$param->code] = true;
            }
            //check unparsed params
            foreach ($data as $key => $item) {
                //skip parsed and attribtes
                if ($key == '@attributes' || !empty($walked[$key])) {
                    continue;
                }
                $param = new \Migrations\Migration\Object\Param();
                $param->object_id = $this->object->id;
                $param->code = $key;
                $param->save();
            }
            if ($model) {
                $model->save();
                return $model->pk();
            }
        }
        return 0;
    }

    private function setModel($data)
    {
        $model = null;
        $keyCol = null;
        $uniques = [];
        foreach ($this->object->params as $param) {
            $options = $param->options ? json_decode($param->options, true) : [];
            if ($param->type == 'item_key') {
                $keyCol = $param->code;
                break;
            } elseif (!empty($options['unique'])) {
                $uniques[$param->code] = $param;
            }
        }
        if ($keyCol && isset($data[$keyCol])) {
            $objectId = \Migrations\Id::get([['parse_id', (string) $data[$keyCol]], ['type', $this->object->model]]);
            if ($objectId) {
                $modelName = $this->object->model;
                $model = $modelName::get($objectId->object_id);
            } else {
                $model = new $this->object->model;
                $model->save(['empty' => true]);
                $objectId = new \Migrations\Id();
                $objectId->object_id = $model->id;
                $objectId->parse_id = (string) $data[$keyCol];
                $objectId->type = $this->object->model;
                $objectId->save();
            }
        } elseif ($uniques) {
            $where = [];
            foreach ($uniques as $code => $param) {
                if (!isset($data[$code])) {
                    return;
                }
                switch ($param->type) {
                    case 'objectLink':
                        $object = \Migrations\Migration\Object::get($param->value);
                        $objectId = \Migrations\Id::get([['parse_id', (string) $data[$code]], ['type', $object->model]]);
                        if (!$objectId) {
                            return;
                        }
                        $modelName = $object->model;
                        $model = $modelName::get($objectId->object_id);
                        $where[] = [$model->index(), $model->pk()];
                        break;
                    case 'relation':
                        $modelName = $this->object->model;
                        $relation = $modelName::getRelation($param->value);
                        $objectId = \Migrations\Id::get([['parse_id', (string) $data[$code]], ['type', $relation['model']]]);
                        if (!$objectId) {
                            return;
                        }
                        $modelName = $relation['model'];
                        $model = $modelName::get($objectId->object_id);
                        $where[] = [$relation['col'], $model->pk()];
                        break;
                }
            }
            if ($where) {
                if ($this->parentParam) {
                    $modelName = $this->parentObject->object->model;
                    $relation = $modelName::getRelation($this->parentParam->param->value);
                    if (!empty($relation['type']) && $relation['type'] == 'many') {
                        $where[] = [$relation['col'], $this->parentModel->pk()];
                    }
                } elseif ($this->parentObject) {
                    $modelName = $this->parentObject->object->model;
                    $where[] = [$modelName::index(), $this->parentModel->pk()];
                }
            }
            if ($where) {
                $modelName = $this->object->model;
                $model = $modelName::get($where);
                if (!$model) {
                    $model = new $this->object->model;
                    foreach ($where as $item) {
                        $model->{$item[0]} = $item[1];
                    }
                }
            }
        }
        return $model;
    }

}