Get design configuration data

@return DataObject
332821
public function getDesignConfig()
    {
        $templates = $this->getTemplate()->getData('store_id');
        $this->storeId = $templates[0];

        if ($this->designConfig === null) {
            //@codingStandardsIgnoreLine
            $this->designConfig = new DataObject(
                ['area' => Area::AREA_FRONTEND, 'store' => $this->storeId]
            );
        }

        return $this->designConfig;
    }
244110
public function getDataModelSettings()
    {
        if (! $this->exists) {
            return array();
        }

        $fieldSettings = array();

        foreach ($this->_fields as $key => $field) {
            if ($field instanceof FieldInterface) {
                $fieldSettings[$key] = $field->getDataModelSettings();
            }
        }

        return $fieldSettings;
    }
1321526
protected function getOtherConfig()
    {
        if (!isset($this->objOtherConfig)) {
            $this->objOtherConfig = $this
                ->getEnvironment()
                ->getBaseConfigRegistry()
                ->getBaseConfig();

            $this
                ->getPanel()
                ->getContainer()
                ->initialize($this->objOtherConfig, $this);
        }

        return $this->objOtherConfig;
    }
974619
public function getConfig()
    {
        if(!$this->_config instanceof ObjectConfig) {
            $this->_config = new ObjectConfig($this->__config);
        }

        return $this->_config;
    }
1065032
public static function getConfigurationObjectServices()
    {
        return ServiceFactory::getInstance()
            ->attach(ServiceInterface::SERVICE_CACHE)
            ->with(ServiceInterface::SERVICE_CACHE)
            ->setOption(CacheService::OPTION_CACHE_NAME, InternalCacheService::CONFIGURATION_OBJECT_CACHE_IDENTIFIER)
            ->setOption(CacheService::OPTION_CACHE_BACKEND, InternalCacheService::get()->getBackendCache())
            ->attach(ServiceInterface::SERVICE_PARENTS)
            ->attach(ServiceInterface::SERVICE_DATA_PRE_PROCESSOR)
            ->attach(ServiceInterface::SERVICE_MIXED_TYPES);
    }
34717
protected function getDatabaseConfig()
    {
        if ($this->app->config()['use_cache']) {
            $key = 'rails.ar.dbconfig';
            if ($dbConfig = $this->app->getService('rails.cache')->read($key)) {
                return $dbConfig;
            }
        }
        
        $connections = $this->getDatabaseConnections();
        if (!$connections) {
            return [[], null, null];
        }
        
        $config  = $this->app->config();
        
        if ($config['active_record']['allow_profiler'] === null) {
            $allowProfiler = ($config['environment'] == 'production' || $config['environment'] == 'test');
        } else {
            $allowProfiler = (bool)$config['active_record']['allow_profiler'];
        }
        
        $options = [
            'allowProfiler' => $allowProfiler
        ];
        
        if (isset($connections[$config['environment']])) {
            $defaultConnction = $config['environment'];
        } elseif (isset($connections['default'])) {
            $defaultConnction = 'default';
        } else {
            $defaultConnction = key($connections);
        }
        
        $dbConfig = [
            $connections,
            $defaultConnction,
            $options
        ];
        
        if ($this->app->config()['use_cache']) {
            $this->app->getService('rails.cache')->write($key, $dbConfig);
        }
        
        return $dbConfig;
    }
860505
public static function config_get_configuration_array($data) {
        $config = array();

        if (isset($data->path)) {
            $config['path'] = $data->path;
        }
        if (isset($data->autocreate)) {
            $config['autocreate'] = $data->autocreate;
        }
        if (isset($data->singledirectory)) {
            $config['singledirectory'] = $data->singledirectory;
        }
        if (isset($data->prescan)) {
            $config['prescan'] = $data->prescan;
        }

        return $config;
    }
1213749
public function getConfiguration(){
        $rest = $this->getService( self::API_UPNP_IGD_CONFIG);
        $rest->GET();

        return $rest->getResult( models\UPnP\UpnpIgdConfig::class);
    }
1170344
public function getDataAttributes()
    {
        $attributes = parent::getDataAttributes();
        
        if ($this->isAjaxEnabled()) {
            
            foreach ($this->getFieldAjaxConfig() as $key => $value) {
                $attributes[sprintf('data-ajax--%s', $key)] = $this->getDataValue($value);
            }
            
        }
        
        return $attributes;
    }
1238189
public function fetchConfigData()
    {
        $this->profiler->start(__METHOD__);
        $metadata = $this->metadataPool->getMetadata(CategoryInterface::class);
        $identifierField = $metadata->getIdentifierField();

        $data = $this->getResource()->fetchConfigData();
        $labels = [];

        foreach ($data as $row) {
            if (isset($labels[$row['parent_id']])) {
                $label = $labels[$row['parent_id']];
            } else {
                $label = [];
            }
            $label[] = $row['name'];
            $labels[$row[$identifierField]] = $label;
        }
        
        $fieldOptions = [];
        foreach ($labels as $id => $label) {
            $fieldOptions[] = [
                'label' => $label = implode(' > ', $label),
                'value' => $id
            ];
        }

        $data = [
            'snowMenuAutoCompleteField' => [
                'type'    => 'category',
                'options' => $fieldOptions,
                'message' => __('Category not found'),
            ],
        ];

        $this->profiler->stop(__METHOD__);

        return $data;
    }
230596
public function dataFromObject()
    {
        $obj             = $this->proto();
        $metadata        = $obj->metadata();
        $adminMetadata   = isset($metadata['admin']) ? $metadata['admin'] : null;
        $collectionIdent = $this->collectionIdent();
        if (!$collectionIdent) {
            $collectionIdent = isset($adminMetadata['default_list']) ? $adminMetadata['default_list'] : '';
        }

        if (isset($adminMetadata['lists'][$collectionIdent])) {
            return $adminMetadata['lists'][$collectionIdent];
        } else {
            return [];
        }
    }
382162
protected function getConfig()
    {
        if ($this->config !== null) {
            return $this->config;
        }

        $config = $this->merge(
            $this->defaultConfig,
            getValue($this->namespace, $this->composerJson)
        );

        if ($this->presetsPath === null || $config === null) {
            return $this->config = $config;
        }

        $presets = $this->loadPresets(getValue($this->presetsPath, $config, []));
        $presetsConfig = array_reduce($presets, $this->merge, array_shift($presets));

        return $this->config = $this->merge($presetsConfig, $config);
    }
1127292
public function getConfiguration(){
        $rest = $this->getService( self::API_LCD_CONFIG);
        $rest->GET();

        return $rest->getResult( models\LCDConfig::class);
    }
1009151
public function getConfiguration()
    {
        if (is_null($this->_configuration)) {
            $this->_configuration = Configuration::get('config');
        }
        return $this->_configuration;
    }
448783
public function getConfiguration()
    {
        if (!$this->_configuration) {

            //If model is using
            if ($this->modelClass) {

                $this->_configuration = $this->_keyStorage->get($this->getKey()) ?: [];
                $modelClass = $this->modelClass;
                if (!$this->_configuration || !($this->_configuration instanceof $modelClass)) {
                    //Initialize new model. Default values must be set in model (init method)
                    $this->_configuration = Yii::createObject($modelClass, $this->modelConfig);
                }

                //Default values from 'attributes'
                if (is_array($this->attributes)) {
                    foreach ($this->attributes as $key => $default) {
                        if ($this->_configuration->{$key} === null) {
                            $this->_configuration->{$key} = $default;
                        }
                    }
                }

            } else {

                //Array configuration
                $dbConfig = $this->_keyStorage->get($this->getKey()) ?: [];

                if (is_array($this->attributes)) {
                    //Needs to filter
                    $config = [];
                    foreach ($this->attributes as $key => $default) {
                        $config[$key] = (isset($dbConfig[$key]) && $dbConfig[$key] !== null) ? $dbConfig[$key] : $default;
                    }
                    $this->_configuration = $config;
                } else {
                    $this->_configuration = $dbConfig;
                }

            }
        }
        return $this->_configuration;
    }
1038842
protected function getFieldConfig()
    {
        $config = parent::getFieldConfig();
        
        if ($values = $this->getValueArray()) {
            
            $data = [];
            
            foreach ($values as $value) {
                
                if ($record = $this->getValueRecord($value)) {
                    $data[] = $this->getResultData($record, true);
                }
                
            }
            
            $config['data'] = $data;
            
        }
        
        return $config;
    }
469123
public static function getConfig()
    {
        if (!is_object(self::$componentConfig)) {
            $config = [];

            // check if we have default config
            if (isset(self::$defaultConfig)) {
                $config = self::$defaultConfig;
            }
            self::$componentConfig = new ConfigObject($config);
        }

        return self::$componentConfig;
    }