Gets providers from Magento configuration.

@return array
337878
private function getProvidersConfig()
    {
        $config = [];
        foreach (self::PROVIDERS as $provider) {
            $config[ucfirst($provider)] = [
                'enabled' => (bool)$this->scopeConfig->getValue(
                    sprintf(self::CONFIG_PATH_SOCIAL_LOGIN_PROVIDER_ENABLED, $provider),
                    ScopeInterface::SCOPE_STORE
                ),
                'keys' => [
                    'key' => $this->scopeConfig->getValue(
                        sprintf(self::CONFIG_PATH_SOCIAL_LOGIN_PROVIDER_KEY, $provider),
                        ScopeInterface::SCOPE_STORE
                    ),
                    'secret' => $this->scopeConfig->getValue(
                        sprintf(self::CONFIG_PATH_SOCIAL_LOGIN_PROVIDER_SECRET, $provider),
                        ScopeInterface::SCOPE_STORE
                    ),
                ]
            ];
        }
        return $config;
    }
339051
public function getPlugins(){
        $config = [];
        $registry = self::getRegistry();

        if ($registry->isRegistered(self::CREATOR)) {
            $config = $registry->get(self::CREATOR);
        }

        if (!isset($config['plugins'])) {
            return [];
        }

        return $config['plugins'];
    }
682691
public function getConfiguration(){
        $rest = $this->getService( self::API_DHCP_CONFIG);
        $rest->GET();

        return $rest->getResult( models\DhcpConfig::class);
    }
730482
protected function config() {/** @var S $s */ $s = $this->s(); return [
		'prefill' => $s->prefill()
		// 2017-07-22
		// It implements the feature:
		// `Add a new option «Prefill the cardholder's name from the billing address?»
		// to the payment modules which require (or accept) the cardholder's name`
		// https://github.com/mage2pro/core/issues/14
		,'prefillCardholder' => $s->prefillCardholder()
		,'requireCardholder' => $s->requireCardholder()
	] + parent::config();}
524050
private function getDistilledConfig()
    {
        $config = [];
        foreach ($this->configParameters as $p) {
            $config[$p->getName()] = $p->getValue();
        }

        return $config;
    }
254342
public function getConfig()
    {
        $config = [];

        $config['general'] = $this->parseGeneral();
        $config['taxonomy'] = $this->parseTaxonomy();
        $config['contenttypes'] = $this->parseContentTypes($config['general']);
        $config['menu'] = $this->parseConfigYaml('menu.yml');
        $config['routing'] = $this->parseConfigYaml('routing.yml');
        $config['permissions'] = $this->parseConfigYaml('permissions.yml');
        $config['extensions'] = $this->parseConfigYaml('extensions.yml');

        return $config;
    }
555826
public function getServiceConfig()
    {
        return array(
            'initializers' => array(
                function ($instance, $sm) {
                    if ($instance instanceof \DlcBase\Module\ModuleNamespaceAwareInterface) {
                        $class           = get_class($instance);
                        $moduleNamespace = substr($class, 0, strpos($class, '\\'));
                        $instance->setModuleNamespace($moduleNamespace);
                    }
                }
            ),
        );
    }
1111321
def get_providers(self):
        
        if self.providers:
            return self.providers

        providers = dict()
        for provider in self.config:
            configurator = provider.lower() + '_config'
            if not hasattr(self, configurator):
                err = 'Provider [{}] not recognized'.format(provider)
                raise ValueError(err)

            provider_config = self.config[provider]
            configurator = getattr(self, configurator)
            providers[provider] = configurator(
                id=provider_config.get('id'),
                secret=provider_config.get('secret'),
                scope=provider_config.get('scope'),
                offline=provider_config.get('offline')
            )

        self.providers = providers
        return self.providers
989421
public function getProviderIcon()
    {
        $icons = $this->providerIcons;

        if (empty($icons)) {
            return null;
        }

        $sizes = [];

        foreach ($icons as $icon) {
            $sizes[$icon['url']] = $icon['size'];
        }

        return static::getBigger($sizes);
    }
824663
public function getConfig() {
		$result = [];
		$pluginName = $this->_getPluginName();
		if (empty($pluginName) || !Configure::check($pluginName)) {
			return $result;
		}

		$result = (array)Configure::read($pluginName);

		return $result;
	}
1095171
public function getDependencyConfig()
    {
        return [
            'aliases'    => [
                MvcAuthAuthorizationInterface::class => Authorization\AclAuthorization::class,
            ],
            'factories' => [
                Authorization\AuthorizationListener::class =>
                    Authorization\AuthorizationListenerFactory::class,
                Authorization\AclAuthorization::class => Factory\AclAuthorizationFactory::class,
            ],
        ];
    }
85778
public function getProviders($provider)
    {
        $name = \is_string($provider) ? $provider : \get_class($provider);

        return Arr::where($this->loadedProviders, function ($value) use ($name) {
            return $value instanceof $name;
        });
    }
805418
public function getAdapters()
    {
        $registry = $this->getRegistry();
        $config = [];
        if ($registry->isRegistered(self::REGISTRY_ENTRY_KEY)) {
            $config = $registry->get(self::REGISTRY_ENTRY_KEY);
        }

        if (isset($config[self::PREVIEWERS_KEY])) {
            return $config[self::PREVIEWERS_KEY];
        }
        return [];
    }
350264
final public function getServices()
    {
        if (is_null($this->serviceProviders)) {
            $this->serviceProviders = $this->getServiceProviders();
        }

        return $this->serviceProviders;
    }
1374544
protected function getLoaderConfig()
    {
        return [
            LoaderInterface::FROM_STRING     => false,
            LoaderInterface::SIMPLEXML       => false,
            LoaderInterface::DOM_CLASS       => __NAMESPACE__.'\\Dom\DOMDocument',
            LoaderInterface::SIMPLEXML_CLASS => __NAMESPACE__.'\\SimpleXMLElement'
        ];
    }
445068
private function getDefaultProviders()
    {
        $defaultProviders = array();

        foreach ($this->defaultProviders as $provider) {
            $defaultProviders[$provider] = $this->getProvider($provider);
        }

        return $defaultProviders;
    }
203332
def get_custom_providers():
    """"""

    providers = getattr(settings, 'SITEMETRICS_PROVIDERS', False)

    if not providers:
        return []

    p_clss = []
    for provider_path in providers:
        path_splitted = provider_path.split('.')
        mod = import_module('.'.join(path_splitted[:-1]))
        p_cls = getattr(mod, path_splitted[-1])
        p_clss.append(p_cls)
    return p_clss