Class luya\admin\ngrest\Config

                public function addField($pointer, $field, array $options = [])
{
    if ($this->hasField($pointer, $field)) {
        return false;
    }
    $options = ArrayHelper::merge([
        'name' => null,
        'i18n' => false,
        'alias' => null,
        'type' => null,
        'extraField' => false,
    ], $options);
    // can not unshift non array value, create array for this pointer.
    if (empty($this->_config[$pointer])) {
        $this->_config[$pointer] = [];
    }
    $this->_config[$pointer] = ArrayHelper::arrayUnshiftAssoc($this->_config[$pointer], $field, $options);
    return true;
}

            

                public function appendFieldOption($fieldName, $optionKey, $optionValue)
{
    foreach ($this->getConfig() as $pointer => $fields) {
        if (is_array($fields)) {
            foreach ($fields as $field) {
                if (isset($field['name'])) {
                    if ($field['name'] == $fieldName) {
                        $this->_config[$pointer][$field['name']][$optionKey] = $optionValue;
                    }
                }
            }
        }
    }
}

            

                public static function createField(array $plugin)
{
    return NgRest::createPluginObject($plugin['type']['class'], $plugin['name'], $plugin['alias'], $plugin['i18n'], $plugin['type']['args']);
}

            

                public function getActiveButtons()
{
    if ($this->_activeButtons === null) {
        $buttons = $this->model->ngRestActiveButtons();
        $btns = [];
        foreach ($buttons as $button) {
            $hash = sha1($button['class']);
            $object = Yii::createObject($button);
            $btns[] = [
                'hash' => $hash,
                'label' => $object->getLabel(),
                'icon' => $object->getIcon(),
                'condition' => $object->getCondition(),
                'permissionLevel' => $object->getPermissionLevel(),
            ];
        }
        $this->_activeButtons = $btns;
    }
    return $this->_activeButtons;
}

            

                public function getActiveSelections()
{
    return $this->_activeSelections;
}

            

                public function getApiEndpoint()
{
    return $this->_apiEndpoint;
}

            

                public function getAttributeGroups()
{
    return $this->_attributeGroups;
}

            

                public function getConfig()
{
    return $this->_config;
}

            

                public function getDefaultOrder()
{
    return $this->_defaultOrder;
}

            

                public function getDefaultOrderDirection()
{
    if (!$this->getDefaultOrder()) {
        return false;
    }
    $direction = is_array($this->getDefaultOrder()) ? current($this->getDefaultOrder()) : null; // us preg split to find in string?
    if ($direction == SORT_ASC || strtolower($direction) == 'asc') {
        return '+';
    }
    if ($direction == SORT_DESC || strtolower($direction) == 'desc') {
        return '-';
    }
    return '+';
}

            

                public function getDefaultOrderField()
{
    if (!$this->getDefaultOrder()) {
        return false;
    }
    return key($this->getDefaultOrder());
}

            

                public function getExtraFields()
{
    if ($this->_extraFields === null) {
        $extraFields = [];
        foreach ($this->getConfig() as $pointer => $fields) {
            if (is_array($fields)) {
                foreach ($fields as $field) {
                    if (isset($field['extraField']) && $field['extraField']) {
                        if (!array_key_exists($field['name'], $extraFields)) {
                            $extraFields[] = $field['name'];
                        }
                    }
                }
            }
        }
        $this->_extraFields = $extraFields;
    }
    return $this->_extraFields;
}

            

                public function getField($pointer, $field)
{
    return $this->hasField($pointer, $field) ? $this->_config[$pointer][$field] : false;
}

            

                public function getFields($pointer, array $fields)
{
    $data = [];
    foreach ($fields as $fieldName) {
        if ($this->getField($pointer, $fieldName)) {
            $data[$fieldName] = $this->getField($pointer, $fieldName);
        }
    }
    return $data;
}

            

                public function getFilters()
{
    if ($this->_filters === null) {
        $this->_filters = $this->model->ngRestFilters();
    }
    return $this->_filters;
}

            

                public function getGroupByExpanded()
{
    return $this->_groupByExpanded;
}

            

                public function getGroupByField()
{
    return $this->_groupByField;
}

            

                public function getHash()
{
    if ($this->_hash === null) {
        $this->_hash = md5((string) $this->getApiEndpoint());
    }
    return $this->_hash;
}

            

                public function getModel()
{
    return $this->_model;
}

            

                public function getOption($key)
{
    return ($this->hasPointer('options') && array_key_exists($key, $this->_config['options'])) ? $this->_config['options'][$key] : false;
}

            

                public function getPlugins()
{
    if ($this->_plugins === null) {
        $plugins = [];
        foreach ($this->getConfig() as $pointer => $fields) {
            if (is_array($fields)) {
                foreach ($fields as $field) {
                    if (isset($field['type'])) {
                        $fieldName = $field['name'];
                        if (!array_key_exists($fieldName, $plugins)) {
                            $plugins[$fieldName] = $field;
                        }
                    }
                }
            }
        }
        $this->_plugins = $plugins;
    }
    return $this->_plugins;
}

            

                public function getPointer($pointer, $defaultValue = false)
{
    return $this->hasPointer($pointer) ? $this->_config[$pointer] : $defaultValue;
}

            

                public function getPointerExtraFields($pointer)
{
    $extraFields = [];
    foreach ($this->getPointer($pointer, []) as $field) {
        if (isset($field['extraField']) && $field['extraField']) {
            $extraFields[] = $field['name'];
        }
    }
    return $extraFields;
}

            

                public function getPointerPlugins($pointer)
{
    $plugins = [];
    foreach ($this->getPointer($pointer, []) as $field) {
        $plugins[] = self::createField($field);
    }
    return $plugins;
}

            

                public function getPrimaryKey()
{
    if ($this->_primaryKey === null) {
        $this->_primaryKey = $this->model->getNgRestPrimaryKey();
    }
    return $this->_primaryKey;
}

            

                public function getRelations()
{
    if ($this->_relations === null) {
        // ensure relations are made not on composite table.
        if ($this->model->ngRestRelations() && (is_countable($this->getPrimaryKey()) ? count($this->getPrimaryKey()) : 0) > 1) {
            throw new InvalidConfigException("Its not allowed to have ngRestRealtions() on models with composite primary keys.");
        }
        // generate relations
        $relations = [];
        foreach ($this->model->generateNgRestRelations() as $relation) {
            /** @var $relation \luya\admin\ngrest\base\NgRestRelationInterface */
            $relations[] = [
                'label' => $relation->getLabel(),
                'apiEndpoint' => $relation->getApiEndpoint(),
                'arrayIndex' => $relation->getArrayIndex(),
                'modelClass' => $relation->getModelClass(),
                'tabLabelAttribute' => $relation->getTabLabelAttribute(),
                'relationLink' => $relation->getRelationLink(),
            ];
        }
        $this->_relations = $relations;
    }
    return $this->_relations;
}

            

                public function getTableName()
{
    return $this->_tableName;
}

            

                public function hasField($pointer, $field)
{
    return $this->getPointer($pointer) ? array_key_exists($field, $this->_config[$pointer]) : false;
}

            

                public function hasPointer($pointer)
{
    return array_key_exists($pointer, $this->_config);
}

            

                public function isDeletable()
{
    return $this->getPointer('delete') === true ? true : false;
}

            

                public function onFinish()
{
    foreach ($this->getPrimaryKey() as $pk) {
        if (!$this->hasField('list', $pk)) {
            $alias = $pk;
            if (array_key_exists($alias, $this->_attributeLabels)) {
                $alias = $this->_attributeLabels[$alias];
            } elseif (strtolower($alias) == 'id') {
                $alias = Module::t('model_pk_id'); // use default translation for IDs if not label is given
            }
            $this->addField('list', $pk, [
                'name' => $pk,
                'alias' => $alias,
                'type' => [
                    'class' => 'luya\admin\ngrest\plugins\Number',
                    'args' => [],
                ],
            ]);
        }
    }
}

            

                public function setActiveButtons(array $buttons)
{
    $this->_activeButtons = $buttons;
}

            

                public function setActiveSelections(array $buttons)
{
    $objects = [];
    foreach ($buttons as $button) {
        if (!array_key_exists('class', $button)) {
            $button['class'] = ActiveSelection::class;
        }
        $objects[] = Yii::createObject($button);
    }
    $this->_activeSelections = $objects;
}

            

                public function setApiEndpoint($apiEndpoint)
{
    $this->_apiEndpoint = $apiEndpoint;
}

            

                public function setAttributeGroups(array $groups)
{
    $this->_attributeGroups = $groups;
}

            

                public function setAttributeLabels(array $labels)
{
    $this->_attributeLabels = $labels;
}

            

                public function setConfig(array $config)
{
    if (!empty($this->_config)) {
        throw new InvalidConfigException("Unable to override an already provided Config.");
    }
    $this->_config = $config;
}

            

                public function setDefaultOrder($defaultOrder)
{
    $this->_defaultOrder = $defaultOrder;
}

            

                public function setFilters(array $filters)
{
    $this->_filters = $filters;
}

            

                public function setGroupByExpanded($groupByExpanded)
{
    $this->_groupByExpanded = $groupByExpanded;
}

            

                public function setGroupByField($groupByField)
{
    $this->_groupByField = $groupByField;
}

            

                public function setModel(NgRestModel $model)
{
    $this->_model = $model;
}

            

                public function setPrimaryKey(array $key)
{
    $this->_primaryKey = $key;
}

            

                public function setRelation(NgRestRelation $relation)
{
    $this->_relations[] = $relation;
}

            

                public function setTableName($tableName)
{
    $this->_tableName = $tableName;
}