Build the UserRegistryConfiguration properties based on the current
user and password.

@return UserRegistryConfiguration properties
510220
private Dictionary<String, Object> buildUserRegistryConfigProps() {
        Hashtable<String, Object> properties = new Hashtable<String, Object>();
        properties.put("config.id", QUICK_START_SECURITY_REGISTRY_ID);
        properties.put("id", QUICK_START_SECURITY_REGISTRY_ID);
        properties.put(UserRegistryService.REGISTRY_TYPE, QUICK_START_SECURITY_REGISTRY_TYPE);
        properties.put(CFG_KEY_USER, config.userName());
        properties.put("service.vendor", "IBM");
        return properties;
    }
966580
public function getUserLibraryInstance()
    {
        if ($this->userLibrary === null) {
            $this->userLibrary = new UserLibraryImpl($this);
        }
        return $this->userLibrary;
    }
888955
public function updateSessionConfiguration()
    {
        $configuration = clone $this->getUserConfiguration();
        $userSession = $this->manager->getRepository('QcmPublicBundle:UserSession')->findOneBy(array(
            'id' => $this->userSession->getId()
        ));

        $userSession->setConfiguration($configuration);
        $this->manager->persist($userSession);
        $this->manager->flush();

        $this->session->set('user_session', $userSession);

        return $this;
    }
145785
protected static function initConfiguration()
    {
        $caching   = self::$registry->getParameter('doozr.kernel.caching');
        $namespace = self::$registry->getParameter('doozr.namespace.flat').'.cache.configuration';

        $cache = Doozr_Loader_Serviceloader::load(
            'cache',
            self::$registry->getParameter('doozr.kernel.caching.container'),
            $namespace,
            [],
            self::$registry->getParameter('doozr.unix'),
            $caching
        );

        // Wire the required instances ...
        self::$registry->getContainer()->getMap()->wire(
            [
                'doozr.configuration.reader.json' => new Doozr_Configuration_Reader_Json(
                    Doozr_Loader_Serviceloader::load('filesystem'),
                    $cache,
                    $caching
                ),
                'doozr.cache.service' => $cache,
            ]
        );

        $configuration = self::$registry->getContainer()->build(
            'doozr.configuration',
            [
                $caching,
            ]
        );

        // Read Kernel configuration
        $configuration->read(
            self::$registry->getPath()->get('configuration').'.config.json'
        );

        // Retrieve list of service configuration files and read them ...
        $serviceConfigurationFiles = self::retrieveServiceConfigurationFiles();

        foreach ($serviceConfigurationFiles as $serviceConfigurationFile) {
            $configuration->read($serviceConfigurationFile);
        }

        // Retrieve list of userland configuration files and read them ...
        $userlandConfigurationFiles = self::retrieveUserlandConfigurationFiles();

        foreach ($userlandConfigurationFiles as $userlandConfigurationFile) {
            $configuration->read($userlandConfigurationFile);
        }

        // Store configuration
        self::$registry->setConfiguration($configuration);

        // Check if debugging is enabled ...
        if (true === self::$registry->getParameter('doozr.kernel.debugging')) {

            // Now add a collector for configuration
            self::$registry->getDebugbar()->addCollector(
                new DebugBar\DataCollector\ConfigCollector(
                    json_decode(json_encode(self::$registry->getConfiguration()->get()), true)
                )
            );
        }

        // Important for bootstrap result
        return true;
    }
142912
protected function registerConfig() {
        $config = new Configuration($this->configFile);
        $this->container->set('config', function() use ($config) {
                return $config;
        });
    }
1351402
protected function initialiseConfiguration()
    {
        $configuration = $this->registerConfiguration($this->environment);

        if ( ! is_array($configuration)) {
            throw new \RuntimeException(sprintf(
                'The configuration must be a valid array (%s given).',
                $this->varToString($configuration)
            ));
        }

        return $this->configuration = new Configuration($configuration);
    }
448877
public Record getUserRegistration()
    {
        Record recUserRegistration = (Record)m_systemRecordOwner.getRecord(UserRegistrationModel.USER_REGISTRATION_FILE);
        if (recUserRegistration == null)
            recUserRegistration = Record.makeRecordFromClassName(UserRegistrationModel.THICK_CLASS, m_systemRecordOwner);
        return recUserRegistration;
    }
515370
private function setUserModelConfig()
    {
        if (config('defender.user_model') == '') {
            if (str_contains($this->app->version(), '5.1')) {
                return config(['defender.user_model' => $this->app['auth']->getProvider()->getModel()]);
            }

            return config(['defender.user_model' => $this->app['auth']->guard()->getProvider()->getModel()]);
        }
    }
713555
public function userRegistrationFormAction()
    {
        $this->checkAccess();
        $user = new User();
        $localeManager = $this->get('claroline.common.locale_manager');
        $termsOfService = $this->get('claroline.common.terms_of_service_manager');
        $facets = $this->facetManager->findForcedRegistrationFacet();
        $form = $this->get('form.factory')->create(
            new BaseProfileType($localeManager, $termsOfService, $this->translator, $facets),
            $user
        );

        return array('form' => $form->createView());
    }
968799
public function getUthandoConfig(): array
    {
        $config             = [];
        $configFilePattern  = join('/', [
            $this->getModulePath(),
            $this->configDirectory,
            $this->filePattern,
        ]);

        foreach (glob($configFilePattern) as $filename) {
            /** @noinspection PhpIncludeInspection */
            $configFile = include $filename;
            $config     = array_merge($config, $configFile);
        }

        return $config;
    }
1183071
protected function getRegistrations() {
        if (!$this->_registrations) {
            $this->_registrations = new AuthTypeRegistrationsList(
                $this->version,
                $this->solution['accountSid'],
                $this->solution['domainSid']
            );
        }

        return $this->_registrations;
    }
1328100
public function getConfigTreeBuilder()
	{
		$treeBuilder = new TreeBuilder();

		$treeBuilder->root('cms_authentication')
			->children()
				->append($this->getPathConfiguration())
				->append($this->getSessionConfiguration())
				->append($this->getUsersConfiguration())
				->append($this->getServicesDefinition())
			->end();

		return $treeBuilder;
	}
125366
public function filterRegistry()
    {
        $filters = [];
        foreach ($this->config->allFilters() as $name) {
            $filters[$name] = $this->buildFilter($name, $this->config->filterConfig($name));
        }
        return new FilterRegistry($filters);
    }
75952
public function GetReadOnlyProperties()
    {
        $properties = parent::GetReadOnlyProperties();
        array_push($properties, 'AccessKey');
        array_push($properties, 'PreregistrationData');
        array_push($properties, 'CardRegistrationURL');
        array_push($properties, 'CardId');
        array_push($properties, 'ResultCode');
        array_push($properties, 'ResultMessage');
        array_push($properties, 'Status');
        return $properties;
    }
699692
public function authProviderBuilders()
    {
        return array(
            $this->buildAuthLogin()->providers(),
            $this->buildAuthHttp()->providers(),
            $this->buildAuthSocial()->providers()
        );
    }
1153411
private void registerQuickStartSecurityRegistryConfiguration() {
        if (bc == null) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "BundleContext is null, we must be deactivated.");
            }
            return;
        }
        if (urConfigReg != null) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "QuickStartSecurityRegistry configuration is already registered.");
            }
            return;
        }
        if (isStringValueUndefined(config.userName()) || isStringValueUndefined(config.userPassword())) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Incomplete configuration. This should already have been reported. Will not register QuickStartSecurityRegistry configuration.");
            }
            return;
        }
        if (config.UserRegistry() != null && config.UserRegistry().length > 0) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Other UserRegistryConfiguration are present, will not register the QuickStartSecurityRegistry configuration.");
            }
            return;
        }
        if (!managementRoles.isEmpty()) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Other ManagementRole are present, will not register the QuickStartSecurityRegistry configuration.");
            }
            return;
        }
        Dictionary<String, Object> props = buildUserRegistryConfigProps();

        quickStartRegistry = new QuickStartSecurityRegistry(config.userName(), Password.create(config.userPassword()));
        urConfigReg = bc.registerService(UserRegistry.class,
                                         quickStartRegistry,
                                         props);
    }
1248734
protected function loadCredentials()
    {
        $instance = $this->getInstance();
        if ($instance && $instance->exists()) {

            $props = $instance->getPropertiesValues([
                $this->getProperty(self::PROPERTY_LOGIN),
                $this->getProperty(self::PROPERTY_PASSWORD)
            ]);

            $data = [
                self::PROPERTY_LOGIN => (string)current($props[self::PROPERTY_LOGIN]),
                self::PROPERTY_PASSWORD => (string)current($props[self::PROPERTY_PASSWORD]),
            ];
        } else {
            $data = [
                self::PROPERTY_LOGIN => '',
                self::PROPERTY_PASSWORD => '',
            ];
        }

        return $data;
    }