Gets a combined configuration model from core and order
@see Radial_Core_Helper_Interface::getConfigModel
@param mixed $store
@return Radial_Core_Model_Config_Registry
509435
public function getConfigModel($store = null)
    {
        return Mage::getModel('radial_core/config_registry')
            ->setStore($store)
            ->addConfigModel(Mage::getSingleton('radial_order/config'));
    }
1131692
public function render(Store $store)
    {
        $sViewName = $store->getViewName();
        $sNamespace = $store->getNamespace();
        // In this view renderer, the namespace must always be prepended to the view name.
        if(substr($sViewName, 0, strlen($sNamespace) + 2) != $sNamespace . '::')
        {
            $sViewName = $sNamespace . '::' . $sViewName;
        }
        // Render the template
        return trim(jaxon()->render($sViewName, $store->getViewData()), " \t\n");
    }
1320045
public function setStoreId($store)
    {
        if ($store instanceof Store) {
            $store = $store->getId();
        }
        $this->storeId = $store;

        return $this;
    }
815495
public function getPrefetchShipping($store = null)
    {
        return $this->getScopeConfig()->isSetFlag(
            self::XML_PATH_PREFETCH_SHIPPING,
            ScopeInterface::SCOPE_STORE,
            $store
        );
    }
277616
public static function getConfiguration()
    {
        if (is_null(self::$_configuration)) {
            self::$_configuration = new stdClass();
            self::$_configuration->trigger = 'never';
            self::$_configuration->filters = new stdClass();

            $file = BP . DIRECTORY_SEPARATOR . 'var' . DIRECTORY_SEPARATOR . 'aoe_profiler.xml';
            if (is_file($file)) {
                $conf = simplexml_load_file($file);
                if ($conf !== false) {
                    self::$_configuration->trigger = (string)$conf->aoe_profiler->trigger;
                    self::$_configuration->captureModelInfo = (bool)(string)$conf->aoe_profiler->captureModelInfo;
                    self::$_configuration->captureBacktraces = (bool)(string)$conf->aoe_profiler->captureBacktraces;
                    self::$_configuration->enableFilters = (bool)(string)$conf->aoe_profiler->enableFilters;
                    if (self::$_configuration->enableFilters) {
                        self::$_configuration->filters->sampling = (float)$conf->aoe_profiler->filters->sampling;
                        self::$_configuration->filters->timeThreshold = (int)$conf->aoe_profiler->filters->timeThreshold;
                        self::$_configuration->filters->memoryThreshold = (int)$conf->aoe_profiler->filters->memoryThreshold;
                        self::$_configuration->filters->requestUriWhiteList = (string)$conf->aoe_profiler->filters->requestUriWhiteList;
                        self::$_configuration->filters->requestUriBlackList = (string)$conf->aoe_profiler->filters->requestUriBlackList;
                    }
                }
            }
        }
        return self::$_configuration;
    }
405745
public function getTranslation($item, $langcode, $store = null)
    {
        $config = $this->getConfig(null, $store);

        if (!empty($config['translation'][$langcode][$item])) {
            return $config['translation'][$langcode][$item];
        }

        if (isset($config[$item])) {
            return $config[$item];
        }

        return '';
    }
735734
protected function _getSourceStore()
    {
        // this may return a Mage_Core_Model_Store or a Mage_Core_Model_Website
        $configSource = $this->_validatorHelper->getConfigSource($this->getRequest());
        // When given a website, get the default store for that website.
        // AMQP config is only at global and website level, so no *current*
        // possibility for the default store to have a different value than the website.
        if ($configSource instanceof Mage_Core_Model_Website) {
            return $configSource->getDefaultStore();
        }
        return $configSource;
    }
475462
public ConfigurationStore getStore() throws ConfigException {
    if (store != null) {
      return store;
    }

    String uriStr = getConfigUri();

    if (uriStr == null) {
      getPfile();

      String configPname = getConfigPname();

      if (configPname == null) {
        throw new ConfigException("Either a uri or property name must be specified");
      }

      uriStr = pfile.getProperty(configPname);
      if (uriStr == null) {
        /* If configPname ends with ".confuri" we'll take the 
           preceding segment as a possible directory
         */
        if (configPname.endsWith(".confuri")) {
          final int lastDotpos = configPname.length() - 8;
          final int pos = configPname
                  .lastIndexOf('.', lastDotpos - 1);
          if (pos > 0) {
            uriStr = configPname.substring(pos + 1, lastDotpos);
          }
        }
      }
      
      if (uriStr == null) {
        throw new ConfigException("No property with name \"" +
                                          configPname + "\"");
      }
    }

    try {
      URI uri= new URI(uriStr);

      String scheme = uri.getScheme();

      if (scheme == null) {
        // Possible non-absolute path
        String path = uri.getPath();

        File f = new File(path);
        if (!f.isAbsolute() && configBase != null) {
          path = configBase + path;
        }

        uri= new URI(path);
        scheme = uri.getScheme();
      }

      if ((scheme == null) || (scheme.equals("file"))) {
        String path = uri.getPath();

        if (getPathSuffix() != null) {
          if (!path.endsWith(File.separator)) {
            path += File.separator;
          }

          path += getPathSuffix() + File.separator;
        }

        store = new ConfigurationFileStore(path);
        return store;
      }

      throw new ConfigException("Unsupported ConfigurationStore: " + uri);
    } catch (URISyntaxException use) {
      throw new ConfigException(use);
    }
  }
412340
public function get_lock_for_store($storename) {
        if (array_key_exists($storename, $this->configstores)) {
            if (array_key_exists($this->configstores[$storename]['lock'], $this->configlocks)) {
                $lock = $this->configstores[$storename]['lock'];
                return $this->configlocks[$lock];
            }
        }
        return $this->get_default_lock();
    }
1094382
public function getStore($item = null)
    {
        if (isset($item)) {
            return gplcart_array_get($this->current_store, $item);
        }

        return $this->current_store;
    }
784798
public function getConfig()
    {
        if (null === $this->config) {
            $this->setConfig(\Zend_Registry::get('config'));
        }
        
        return $this->config;
    }
751421
public function getConfig(string $id): Config
    {
        // TODO: Use null coalescing assignment operator.
        $this->configs[$id] = $this->configs[$id] ?? $this->registerConfig($id);

        return $this->configs[$id];
    }
952735
public function getConfiguration(array $config, ContainerBuilder $container)
    {
        $configuration = $this->getConfigurationInstance();
        if ($configuration) {
            $container->addObjectResource($configuration);
        }

        return $configuration;
    }
685643
protected function getCreatorConfig(core_kernel_classes_Resource $item){

        $config = new CreatorConfig();

        $ext = \common_ext_ExtensionsManager::singleton()->getExtensionById('taoQtiItem');
        $creatorConfig = $ext->getConfig('qtiCreator');

        if (is_array($creatorConfig)) {
            foreach ($creatorConfig as $prop => $value) {
                $config->setProperty($prop, $value);
            }
        }

        $config->setProperty('uri', $item->getUri());
        $config->setProperty('label', $item->getLabel());

        //set the current data lang in the item content to keep the integrity
        //@todo : allow preview in a language other than the one in the session
        $lang = \common_session_SessionManager::getSession()->getDataLanguage();
        $config->setProperty('lang', $lang);

        //base url:
        $url = tao_helpers_Uri::url('getFile', 'QtiCreator', 'taoQtiItem', array(
            'uri' => $item->getUri(),
            'lang' => $lang,
            'relPath' => ''
        ));
        $config->setProperty('baseUrl', $url);

        //map the multi column config to the plugin
        //TODO migrate the config
        if($config->getProperty('multi-column') == true){
            $config->addPlugin('blockAdder', 'taoQtiItem/qtiCreator/plugins/content/blockAdder', 'content');
        }

        $mediaSourcesUrl = tao_helpers_Uri::url(
            'getMediaSources',
            'QtiCreator',
            'taoQtiItem'
        );

        $config->setProperty('mediaSourcesUrl', $mediaSourcesUrl);

        //initialize all registered hooks:
        $hookClasses = HookRegistry::getRegistry()->getMap();
        foreach ($hookClasses as $hookClass) {
            $hook = new $hookClass();
            $hook->init($config);
        }

        $config->init();

        return $config;
    }
823435
public static function factory($storage)
    {
        switch ($storage) {
            case 'apc':
                return new Storage\Apc(Cache::storage('apc'));

            case 'cookie':
                return new Storage\Cookie();

            case 'file':
                return new Storage\File(Config::get('session.storage_path'));

            case 'pdo':
                return new Storage\Pdo(Pdo\Factory::get(Config::get('session.database')));

            case 'memcached':
                return new Storage\Memcached(Cache::storage('memcached'));

            case 'memory':
                return new Storage\Memory();

            case 'redis':
                return new Storage\Redis(Cache::storage('redis'));

            case 'dba':
                return new Storage\Dba(Cache::storage('dba'));

            default:
                throw new \RuntimeException("Session storage [$storage] is not supported.");
        }
    }
493724
public function uploadConfig($store)
    {
        parent::uploadConfig($store);

        // Upload configured synonyms {@see SynonymsKnowlegebaseSiteConfig}
        // Getting the Main site Configuration. because Synonyms text field only
        // enabled in main site( subsite 0)
        $siteConfig = SiteConfig::get()->filter([
            "SubsiteID" => 0,
        ])->First();

        if ($siteConfig->SearchSynonyms) {
            $store->uploadString(
                $this->getIndexName(),
                'synonyms.txt',
                $siteConfig->SearchSynonyms
            );
        }
    }
871985
public static function config($key)
    {
        $app = Strata::app();
        if (!is_null($app)) {
            return $app->getConfig($key);
        }
    }