org.gluu.oxtrust.action.ManagePersonAuthenticationAction クラス

org.gluu.oxtrust.action.ManagePersonAuthenticationAction の継承関係図

org.gluu.oxtrust.action.ManagePersonAuthenticationAction 連携図

公開メンバ関数
boolean	isAuthenticationRecaptchaEnabled ()
void	setAuthenticationRecaptchaEnabled (boolean authenticationRecaptchaEnabled)
List< PassportConfiguration >	getLdapPassportConfigurations ()
void	setLdapPassportConfigurations (List< PassportConfiguration > ldapPassportConfigurations)
String	modify ()
String	modifyImpl ()
String	save () throws JsonParseException, JsonMappingException, IOException
String	cancel ()
boolean	updateAuthConf (GluuAppliance appliance)
List< String >	getPersonAuthenticationConfigurationNames ()
String	testLdapConnection (GluuLdapConfiguration ldapConfig)
void	updateLdapBindPassword (GluuLdapConfiguration ldapConfig)
String	updateLdapBindPassword (String bindPassword)
boolean	isExistLdapConfigIdpAuthConf ()
void	addItemToSimpleProperties (List< SimpleProperty > simpleProperties)
void	removeItemFromSimpleProperties (List< SimpleProperty > simpleProperties, SimpleProperty simpleProperty)
String	getAuthenticationMode ()
void	setAuthenticationMode (String authenticationMode)
String	getOxTrustAuthenticationMode ()
void	setOxTrustAuthenticationMode (String oxTrustAuthenticationMode)
boolean	isInitialized ()
LdapOxPassportConfiguration	getLdapOxPassportConfiguration ()
void	setLdapOxPassportConfiguration (LdapOxPassportConfiguration ldapOxPassportConfiguration)
String	getId (Object obj)
void	addStrategy ()
void	addField (PassportConfiguration removePassportConfiguration)
GluuBoolean	getPassportEnable ()
void	setPassportEnable (GluuBoolean passportEnable)
List< GluuLdapConfiguration >	getSourceConfigs ()
void	setSourceConfigs (List< GluuLdapConfiguration > sourceConfigs)
void	addSourceConfig ()
void	addLdapConfig (List< GluuLdapConfiguration > ldapConfigList)
void	removeLdapConfig (List< GluuLdapConfiguration > ldapConfigList, GluuLdapConfiguration removeLdapConfig)
GluuLdapConfiguration	getActiveLdapConfig ()
void	updateBindPassword ()
void	setActiveLdapConfig (GluuLdapConfiguration activeLdapConfig)
void	addItemToSimpleCustomProperties (List< SimpleCustomProperty > simpleCustomProperties)
void	removeItemFromSimpleCustomProperties (List< SimpleCustomProperty > simpleCustomProperties, SimpleCustomProperty simpleCustomProperty)
void	removeStrategy (PassportConfiguration removePassportConfiguration)
String	getRecaptchaSiteKey ()
void	setRecaptchaSiteKey (String recaptchaSiteKey)
String	getRecaptchaSecretKey ()
void	setRecaptchaSecretKey (String recaptchaSecretKey)
AppConfiguration	getOxTrustappConfiguration ()
void	setOxTrustappConfiguration (AppConfiguration oxTrustappConfiguration)

非公開メンバ関数
String	getFirstConfigName (List< OxIDPAuthConf > idpConfs)
void	reset ()
GluuLdapConfiguration	mapLdapConfig (String config) throws JsonParseException, JsonMappingException, IOException
Object	jsonToObject (String json, Class<?> clazz) throws JsonParseException, JsonMappingException, IOException
String	objectToJson (Object obj) throws JsonGenerationException, JsonMappingException, IOException
String	buildServersString (List< SimpleProperty > servers)
List< OxIDPAuthConf >	getIDPAuthConfOrNull (GluuAppliance appliance)
void	setAuthenticationRecaptcha ()
void	getAuthenticationRecaptcha ()

非公開変数類
Logger	log
FacesMessages	facesMessages
ConversationService	conversationService
ApplianceService	applianceService
AbstractCustomScriptService	customScriptService
PassportService	passportService
ConfigurationFactory	configurationFactory
EncryptionService	encryptionService
boolean	existLdapConfigIdpAuthConf
List< CustomScript >	customScripts
List< GluuLdapConfiguration >	sourceConfigs
GluuLdapConfiguration	activeLdapConfig
String	authenticationMode = "auth_ldap_server"
String	oxTrustAuthenticationMode
String	recaptchaSiteKey
String	recaptchaSecretKey
List< String >	customAuthenticationConfigNames
boolean	initialized
GluuBoolean	passportEnable = GluuBoolean.DISABLED
boolean	authenticationRecaptchaEnabled = false
LdapOxPassportConfiguration	ldapOxPassportConfiguration
List< PassportConfiguration >	ldapPassportConfigurations
JsonConfigurationService	jsonConfigurationService
AppConfiguration	oxTrustappConfiguration

静的非公開変数類
static final String	CLIENT_SECRET = "clientSecret"
static final String	CLIENT_ID = "clientID"
static final long	serialVersionUID = -4470460481895022468L

詳解

Action class for configuring person authentication

著者

Yuriy Movchan Date: 16/11/2010

関数詳解

addField()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.addField ( PassportConfiguration  removePassportConfiguration )

inline

                                                                                {
                for (PassportConfiguration passportConfig : this.ldapPassportConfigurations) {
                        if (System.identityHashCode(removePassportConfiguration) == System.identityHashCode(passportConfig)) {
                                if (passportConfig.getFieldset() == null) {
                                        passportConfig.setFieldset(new ArrayList<SimpleExtendedCustomProperty>());
                                }
                                passportConfig.getFieldset().add(new SimpleExtendedCustomProperty());
                        }
                }
        }

addItemToSimpleCustomProperties()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.addItemToSimpleCustomProperties ( List< SimpleCustomProperty >  simpleCustomProperties )

inline

org.gluu.oxtrust.model.SimpleCustomPropertiesListModelを実装しています。

                                                                                                       {
                simpleCustomProperties.add(new SimpleExtendedCustomProperty("", ""));
        }

addItemToSimpleProperties()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.addItemToSimpleProperties ( List< SimpleProperty >  simpleProperties )

inline

org.gluu.oxtrust.model.SimplePropertiesListModelを実装しています。

                                                                                     {
                if (simpleProperties != null) {
                        simpleProperties.add(new SimpleProperty(""));
                }
        }

addLdapConfig()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.addLdapConfig ( List< GluuLdapConfiguration >  ldapConfigList )

inline

org.gluu.oxtrust.model.LdapConfigurationModelを実装しています。

                                                                              {
                GluuLdapConfiguration ldapConfiguration = new GluuLdapConfiguration();
                ldapConfiguration.setBindPassword("");
                ldapConfigList.add(ldapConfiguration);
        }

addSourceConfig()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.addSourceConfig ( )

inline

                                      {
                addLdapConfig(this.getSourceConfigs());
        }

addStrategy()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.addStrategy ( )

inline

                                  {
                if (ldapPassportConfigurations == null) {
                        ldapPassportConfigurations = new ArrayList<PassportConfiguration>();
                }
                SimpleExtendedCustomProperty clientIDField = new SimpleExtendedCustomProperty();
                clientIDField.setValue1(CLIENT_ID);
                clientIDField.setDescription(facesMessages
                                .evalResourceAsString("#{msg['manageAuthentication.passport.strategy.clientIDFieldHint']}"));
                SimpleExtendedCustomProperty clientSecretField = new SimpleExtendedCustomProperty();
                clientSecretField.setValue1(CLIENT_SECRET);
                clientSecretField.setDescription(facesMessages
                                .evalResourceAsString("#{msg['manageAuthentication.passport.strategy.clientSecretFieldHint']}"));
                PassportConfiguration passportConfiguration = new PassportConfiguration();
                passportConfiguration.setFieldset(new ArrayList<SimpleExtendedCustomProperty>());
                passportConfiguration.getFieldset().add(clientIDField);
                passportConfiguration.getFieldset().add(clientSecretField);
                this.ldapPassportConfigurations.add(passportConfiguration);
        }

buildServersString()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.buildServersString ( List< SimpleProperty >  servers )

inlineprivate

                                                                        {
                StringBuilder sb = new StringBuilder();

                if (servers == null) {
                        return sb.toString();
                }

                boolean first = true;
                for (SimpleProperty server : servers) {
                        if (first) {
                                first = false;
                        } else {
                                sb.append(",");
                        }

                        sb.append(server.getValue());
                }

                return sb.toString();
        }

cancel()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.cancel ( )

inline

                               {
                facesMessages.add(FacesMessage.SEVERITY_INFO, facesMessages.evalResourceAsString("#{msg['configuration.manageAuthentication.updateFailed']}"));
                conversationService.endConversation();

                return OxTrustConstants.RESULT_SUCCESS;
        }

getActiveLdapConfig()

GluuLdapConfiguration org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getActiveLdapConfig ( )

inline

                                                           {
                return activeLdapConfig;
        }

getAuthenticationMode()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getAuthenticationMode ( )

inline

                                              {
                return authenticationMode;
        }

getAuthenticationRecaptcha()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getAuthenticationRecaptcha ( )

inlineprivate

                                                 {
                this.oxTrustappConfiguration=jsonConfigurationService.getOxTrustappConfiguration();
                this.recaptchaSecretKey = oxTrustappConfiguration.getRecaptchaSecretKey();
                this.recaptchaSiteKey = oxTrustappConfiguration.getRecaptchaSiteKey();
                this.authenticationRecaptchaEnabled = oxTrustappConfiguration.isAuthenticationRecaptchaEnabled();
                
        }

getFirstConfigName()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getFirstConfigName ( List< OxIDPAuthConf >  idpConfs )

inlineprivate

                                                                        {
                if ((idpConfs == null) || idpConfs.isEmpty()) {
                        return null;
                }

                return idpConfs.get(0).getName();
        }

getId()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getId ( Object  obj )

inline

                                        {
                return "c" + System.identityHashCode(obj) + "Id";
        }

getIDPAuthConfOrNull()

List<OxIDPAuthConf> org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getIDPAuthConfOrNull ( GluuAppliance  appliance )

inlineprivate

                                                                                  {
                List<OxIDPAuthConf> idpConfs = appliance.getOxIDPAuthentication();
                List<OxIDPAuthConf> authIdpConfs = new ArrayList<OxIDPAuthConf>();
                if (idpConfs != null) {
                        for (OxIDPAuthConf idpConf : idpConfs) {
                                if (idpConf.getType().equalsIgnoreCase("auth")) {
                                        authIdpConfs.add(idpConf);
                                }
                        }
                }
                return authIdpConfs;

        }

getLdapOxPassportConfiguration()

LdapOxPassportConfiguration org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getLdapOxPassportConfiguration ( )

inline

                                                                            {
                return ldapOxPassportConfiguration;
        }

getLdapPassportConfigurations()

List<PassportConfiguration> org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getLdapPassportConfigurations ( )

inline

                                                                           {
                for (PassportConfiguration configuration : ldapPassportConfigurations) {
                        if (configuration.getFieldset() == null) {
                                configuration.setFieldset(new ArrayList<SimpleExtendedCustomProperty>());
                        }
                }
                return ldapPassportConfigurations;
        }

getOxTrustappConfiguration()

AppConfiguration org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getOxTrustappConfiguration ( )

inline

                                                             {
                return oxTrustappConfiguration;
        }

getOxTrustAuthenticationMode()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getOxTrustAuthenticationMode ( )

inline

                                                     {
                return oxTrustAuthenticationMode;
        }

getPassportEnable()

GluuBoolean org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getPassportEnable ( )

inline

                                               {
                return passportEnable;
        }

getPersonAuthenticationConfigurationNames()

List<String> org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getPersonAuthenticationConfigurationNames ( )

inline

                                                                        {
                if (this.customAuthenticationConfigNames == null) {
                        this.customAuthenticationConfigNames = new ArrayList<String>();
                        for (CustomScript customScript : this.customScripts) {
                                if (customScript.isEnabled()) {
                                        String name = customScript.getName();
                                        if (StringHelper.isEmpty(name)) {
                                                continue;
                                        }

                                        this.customAuthenticationConfigNames.add(customScript.getName());
                                }
                        }

                        boolean internalServerName = true;

                        for (GluuLdapConfiguration ldapConfig : this.sourceConfigs) {
                                if ((ldapConfig != null) && StringHelper.isNotEmpty(ldapConfig.getConfigId())) {
                                        this.customAuthenticationConfigNames.add(ldapConfig.getConfigId());
                                        internalServerName = false;
                                        break;
                                }
                        }

                        if (internalServerName) {
                                this.customAuthenticationConfigNames.add(OxConstants.SCRIPT_TYPE_INTERNAL_RESERVED_NAME);
                        }
                }

                return this.customAuthenticationConfigNames;
        }

getRecaptchaSecretKey()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getRecaptchaSecretKey ( )

inline

                                              {
                return recaptchaSecretKey;
        }

getRecaptchaSiteKey()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getRecaptchaSiteKey ( )

inline

                                            {
                return recaptchaSiteKey;
        }

getSourceConfigs()

List<GluuLdapConfiguration> org.gluu.oxtrust.action.ManagePersonAuthenticationAction.getSourceConfigs ( )

inline

                                                              {
                return sourceConfigs;
        }

isAuthenticationRecaptchaEnabled()

boolean org.gluu.oxtrust.action.ManagePersonAuthenticationAction.isAuthenticationRecaptchaEnabled ( )

inline

                                                          {
                return authenticationRecaptchaEnabled;
        }

isExistLdapConfigIdpAuthConf()

boolean org.gluu.oxtrust.action.ManagePersonAuthenticationAction.isExistLdapConfigIdpAuthConf ( )

inline

                                                      {
                return existLdapConfigIdpAuthConf;
        }

isInitialized()

boolean org.gluu.oxtrust.action.ManagePersonAuthenticationAction.isInitialized ( )

inline

                                       {
                return initialized;
        }

jsonToObject()

Object org.gluu.oxtrust.action.ManagePersonAuthenticationAction.jsonToObject ( String  json, Class<?>  clazz  ) throws JsonParseException, JsonMappingException, IOException

inlineprivate

                                                                                     {
                ObjectMapper mapper = new ObjectMapper();
                Object clazzObject = mapper.readValue(json, clazz);
                return clazzObject;
        }

mapLdapConfig()

GluuLdapConfiguration org.gluu.oxtrust.action.ManagePersonAuthenticationAction.mapLdapConfig ( String  config ) throws JsonParseException, JsonMappingException, IOException

inlineprivate

                                                                                     {
                return (GluuLdapConfiguration) jsonToObject(config, GluuLdapConfiguration.class);
        }

modify()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.modify ( )

inline

                               {
                String outcome = modifyImpl();

                if (OxTrustConstants.RESULT_FAILURE.equals(outcome)) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                        facesMessages.evalResourceAsString("#{msg['configuration.manageAuthentication.failToPrepareUpdate']}"));
                        conversationService.endConversation();
                }

                return outcome;
        }

modifyImpl()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.modifyImpl ( )

inline

                                   {
                if (this.initialized) {
                        return OxTrustConstants.RESULT_SUCCESS;
                }

                try {
                        GluuAppliance appliance = applianceService.getAppliance();

                        if (appliance == null) {
                                return OxTrustConstants.RESULT_FAILURE;
                        }
                        passportEnable = appliance.getPassportEnabled();
                        log.info("passport enabled value  : '{}'", passportEnable);
                        this.customScripts = customScriptService.findCustomScripts(
                                        Arrays.asList(CustomScriptType.PERSON_AUTHENTICATION), "displayName", "oxLevel", "gluuStatus");

                        List<OxIDPAuthConf> list = getIDPAuthConfOrNull(appliance);
                        this.sourceConfigs = new ArrayList<GluuLdapConfiguration>();
                        if (list != null) {
                                for (OxIDPAuthConf oxIDPAuthConf : list) {
                                        GluuLdapConfiguration oxldapConfig = mapLdapConfig(oxIDPAuthConf.getConfig());
                                        this.sourceConfigs.add(oxldapConfig);
                                }
                        }
                        getAuthenticationRecaptcha();
                        this.authenticationMode = appliance.getAuthenticationMode();
                        this.oxTrustAuthenticationMode = appliance.getOxTrustAuthenticationMode();

                        ldapOxPassportConfiguration = passportService.loadConfigurationFromLdap();
                        if (ldapOxPassportConfiguration == null) {
                                ldapOxPassportConfiguration = new LdapOxPassportConfiguration();
                        }
                        this.ldapPassportConfigurations = ldapOxPassportConfiguration.getPassportConfigurations();
                        if (ldapPassportConfigurations == null) {
                                ldapPassportConfigurations = new ArrayList<PassportConfiguration>();
                        }
                } catch (Exception ex) {
                        log.error("Failed to load appliance configuration", ex);

                        return OxTrustConstants.RESULT_FAILURE;
                }

                this.initialized = true;

                return OxTrustConstants.RESULT_SUCCESS;
        }

objectToJson()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.objectToJson ( Object  obj ) throws JsonGenerationException, JsonMappingException, IOException

inlineprivate

                                                                                                                  {
                ObjectMapper mapper = new ObjectMapper();
                return mapper.writeValueAsString(obj);
        }

removeItemFromSimpleCustomProperties()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.removeItemFromSimpleCustomProperties ( List< SimpleCustomProperty >  simpleCustomProperties, SimpleCustomProperty  simpleCustomProperty  )

inline

org.gluu.oxtrust.model.SimpleCustomPropertiesListModelを実装しています。

                                                                   {
                if (simpleCustomProperties != null) {
                        simpleCustomProperties.remove(simpleCustomProperty);
                }
        }

removeItemFromSimpleProperties()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.removeItemFromSimpleProperties ( List< SimpleProperty >  simpleProperties, SimpleProperty  simpleProperty  )

inline

org.gluu.oxtrust.model.SimplePropertiesListModelを実装しています。

                                                                                                                         {
                if (simpleProperties != null) {
                        simpleProperties.remove(simpleProperty);
                }
        }

removeLdapConfig()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.removeLdapConfig ( List< GluuLdapConfiguration >  ldapConfigList, GluuLdapConfiguration  removeLdapConfig  )

inline

org.gluu.oxtrust.model.LdapConfigurationModelを実装しています。

                                                                                                                         {
                for (Iterator<GluuLdapConfiguration> iterator = ldapConfigList.iterator(); iterator.hasNext();) {
                        GluuLdapConfiguration ldapConfig = iterator.next();
                        if (System.identityHashCode(removeLdapConfig) == System.identityHashCode(ldapConfig)) {
                                iterator.remove();
                                return;
                        }
                }
        }

removeStrategy()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.removeStrategy ( PassportConfiguration  removePassportConfiguration )

inline

                                                                                      {
                for (Iterator<PassportConfiguration> iterator = this.ldapPassportConfigurations.iterator(); iterator
                                .hasNext();) {
                        PassportConfiguration passportConfiguration = iterator.next();
                        if (System.identityHashCode(removePassportConfiguration) == System
                                        .identityHashCode(passportConfiguration)) {
                                iterator.remove();
                                return;
                        }
                }
        }

reset()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.reset ( )

inlineprivate

                             {
                this.customAuthenticationConfigNames = null;
        }

save()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.save ( ) throws JsonParseException, JsonMappingException, IOException

inline

                                                                                          {
                try {
                        // Reload entry to include latest changes
                        GluuAppliance appliance = applianceService.getAppliance();

                        boolean updateAuthenticationMode = false;
                        boolean updateOxTrustAuthenticationMode = false;

                        String oldAuthName = getFirstConfigName(appliance.getOxIDPAuthentication());
                        if (oldAuthName != null) {
                                if (oldAuthName.equals(this.authenticationMode)) {
                                        updateAuthenticationMode = true;
                                }
                                if (oldAuthName.equals(this.oxTrustAuthenticationMode)) {
                                        updateOxTrustAuthenticationMode = true;
                                }
                        }

                        updateAuthConf(appliance);

                        String newAuthName = getFirstConfigName(appliance.getOxIDPAuthentication());
                        String updatedAuthMode = updateAuthenticationMode ? newAuthName : this.authenticationMode;
                        String updatedOxTrustAuthMode = updateOxTrustAuthenticationMode ? newAuthName
                                        : this.oxTrustAuthenticationMode;
                        appliance.setAuthenticationMode(updatedAuthMode);
                        appliance.setOxTrustAuthenticationMode(updatedOxTrustAuthMode);
                        setAuthenticationRecaptcha();
                        appliance.setPassportEnabled(passportEnable);

                        applianceService.updateAppliance(appliance);

                        ldapOxPassportConfiguration.setPassportConfigurations(ldapPassportConfigurations);

                        passportService.updateLdapOxPassportConfiguration(ldapOxPassportConfiguration);
                } catch (BasePersistenceException ex) {
                        log.error("Failed to update appliance configuration", ex);
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to update appliance");
                        return OxTrustConstants.RESULT_FAILURE;
                }

                reset();

                facesMessages.add(FacesMessage.SEVERITY_INFO, facesMessages.evalResourceAsString("#{msg['configuration.manageAuthentication.updateSucceed']}"));
                conversationService.endConversation();

                return OxTrustConstants.RESULT_SUCCESS;
        }

setActiveLdapConfig()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.setActiveLdapConfig ( GluuLdapConfiguration  activeLdapConfig )

inline

org.gluu.oxtrust.model.LdapConfigurationModelを実装しています。

                                                                                {
                this.activeLdapConfig = activeLdapConfig;
        }

setAuthenticationMode()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.setAuthenticationMode ( String  authenticationMode )

inline

                                                                     {
                this.authenticationMode = authenticationMode;
        }

setAuthenticationRecaptcha()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.setAuthenticationRecaptcha ( )

inlineprivate

                                                 {
                this.oxTrustappConfiguration=jsonConfigurationService.getOxTrustappConfiguration();
                oxTrustappConfiguration.setRecaptchaSecretKey(this.recaptchaSecretKey);
                oxTrustappConfiguration.setRecaptchaSiteKey(this.recaptchaSiteKey);
                oxTrustappConfiguration.setAuthenticationRecaptchaEnabled(authenticationRecaptchaEnabled);
                jsonConfigurationService.saveOxTrustappConfiguration(this.oxTrustappConfiguration);
                
        }

setAuthenticationRecaptchaEnabled()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.setAuthenticationRecaptchaEnabled ( boolean  authenticationRecaptchaEnabled )

inline

                                                                                              {
                this.authenticationRecaptchaEnabled = authenticationRecaptchaEnabled;
        }

setLdapOxPassportConfiguration()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.setLdapOxPassportConfiguration ( LdapOxPassportConfiguration  ldapOxPassportConfiguration )

inline

                                                                                                            {
                this.ldapOxPassportConfiguration = ldapOxPassportConfiguration;
        }

setLdapPassportConfigurations()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.setLdapPassportConfigurations ( List< PassportConfiguration >  ldapPassportConfigurations )

inline

                                                                                                          {
                this.ldapPassportConfigurations = ldapPassportConfigurations;
        }

setOxTrustappConfiguration()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.setOxTrustappConfiguration ( AppConfiguration  oxTrustappConfiguration )

inline

                                                                                         {
                this.oxTrustappConfiguration = oxTrustappConfiguration;
        }

setOxTrustAuthenticationMode()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.setOxTrustAuthenticationMode ( String  oxTrustAuthenticationMode )

inline

                                                                                   {
                this.oxTrustAuthenticationMode = oxTrustAuthenticationMode;
        }

setPassportEnable()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.setPassportEnable ( GluuBoolean  passportEnable )

inline

                                                                  {
                this.passportEnable = passportEnable;
        }

setRecaptchaSecretKey()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.setRecaptchaSecretKey ( String  recaptchaSecretKey )

inline

                                                                     {
                this.recaptchaSecretKey = recaptchaSecretKey;
        }

setRecaptchaSiteKey()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.setRecaptchaSiteKey ( String  recaptchaSiteKey )

inline

                                                                 {
                this.recaptchaSiteKey = recaptchaSiteKey;
        }

setSourceConfigs()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.setSourceConfigs ( List< GluuLdapConfiguration >  sourceConfigs )

inline

                                                                                {
                this.sourceConfigs = sourceConfigs;
        }

testLdapConnection()

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.testLdapConnection ( GluuLdapConfiguration  ldapConfig )

inline

                                                                           {
                try {
                        FileConfiguration configuration = new FileConfiguration(ConfigurationFactory.LDAP_PROPERTIES_FILE);
                        if (!configuration.isLoaded()) {
                                configuration = new FileConfiguration(ConfigurationFactory.LDAP_DEFAULT_PROPERTIES_FILE);
                        }
                        Properties properties = configuration.getProperties();
                        properties.setProperty("bindDN", ldapConfig.getBindDN());
                        properties.setProperty("bindPassword", ldapConfig.getBindPassword());
                        properties.setProperty("servers", buildServersString(ldapConfig.getServers()));
                        properties.setProperty("useSSL", Boolean.toString(ldapConfig.isUseSSL()));

                        LdapConnectionProvider connectionProvider = new LdapConnectionProvider(
                                        PropertiesDecrypter.decryptProperties(properties, configurationFactory.getCryptoConfigurationSalt()));
                        if (connectionProvider.isConnected()) {
                                connectionProvider.closeConnectionPool();

                                facesMessages.add(FacesMessage.SEVERITY_INFO, facesMessages.evalResourceAsString("#{msg['configuration.manageAuthentication.ldap.testSucceed']}"));

                                return OxTrustConstants.RESULT_SUCCESS;

                        }
                        if (connectionProvider.getConnectionPool() != null) {
                                connectionProvider.closeConnectionPool();
                        }
                } catch (Exception ex) {
                        log.error("Could not connect to LDAP", ex);
                }

                facesMessages.add(FacesMessage.SEVERITY_ERROR, facesMessages.evalResourceAsString("#{msg['configuration.manageAuthentication.ldap.testFailed']}"));

                return OxTrustConstants.RESULT_FAILURE;
        }

updateAuthConf()

boolean org.gluu.oxtrust.action.ManagePersonAuthenticationAction.updateAuthConf ( GluuAppliance  appliance )

inline

                                                               {
                try {
                        List<OxIDPAuthConf> idpConf = new ArrayList<OxIDPAuthConf>();
                        for (GluuLdapConfiguration ldapConfig : this.sourceConfigs) {
                                if (ldapConfig.isUseAnonymousBind()) {
                                        ldapConfig.setBindDN(null);
                                }

                                OxIDPAuthConf ldapConfigIdpAuthConf = new OxIDPAuthConf();
                                ldapConfig.updateStringsLists();
                                ldapConfigIdpAuthConf.setType("auth");
                                ldapConfigIdpAuthConf.setVersion(ldapConfigIdpAuthConf.getVersion() + 1);
                                ldapConfigIdpAuthConf.setName(ldapConfig.getConfigId());
                                ldapConfigIdpAuthConf.setEnabled(ldapConfig.isEnabled());
                                ldapConfigIdpAuthConf.setConfig(objectToJson(ldapConfig));

                                idpConf.add(ldapConfigIdpAuthConf);
                        }

                        appliance.setOxIDPAuthentication(idpConf);
                } catch (Exception ex) {
                        log.error("An Error occured ", ex);

                        return false;
                }

                return true;
        }

updateBindPassword()

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.updateBindPassword ( )

inline

                                         {
                if (this.activeLdapConfig == null) {
                        return;
                }

                try {
                        this.activeLdapConfig.setBindPassword(encryptionService.encrypt(this.activeLdapConfig.getBindPassword()));
                } catch (EncryptionException ex) {
                        log.error("Failed to encrypt password", ex);
                }
        }

updateLdapBindPassword() [1/2]

void org.gluu.oxtrust.action.ManagePersonAuthenticationAction.updateLdapBindPassword ( GluuLdapConfiguration  ldapConfig )

inline

                                                                             {
                log.info("hello setting passoword" + ldapConfig.getPrimaryKey());
                for (Iterator<GluuLdapConfiguration> iterator = sourceConfigs.iterator(); iterator.hasNext();) {
                        GluuLdapConfiguration ldapConfig1 = iterator.next();

                }
        }

updateLdapBindPassword() [2/2]

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.updateLdapBindPassword ( String  bindPassword )

inline

                                                                  {
                String encryptedLdapBindPassword = null;
                try {
                        encryptedLdapBindPassword = encryptionService.encrypt(bindPassword);
                        return encryptedLdapBindPassword;
                } catch (EncryptionException ex) {
                        log.error("Failed to encrypt LDAP bind password", ex);
                }

                return null;
        }

メンバ詳解

activeLdapConfig

GluuLdapConfiguration org.gluu.oxtrust.action.ManagePersonAuthenticationAction.activeLdapConfig

private

applianceService

ApplianceService org.gluu.oxtrust.action.ManagePersonAuthenticationAction.applianceService

private

authenticationMode

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.authenticationMode = "auth_ldap_server"

private

authenticationRecaptchaEnabled

boolean org.gluu.oxtrust.action.ManagePersonAuthenticationAction.authenticationRecaptchaEnabled = false

private

CLIENT_ID

final String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.CLIENT_ID = "clientID"

staticprivate

CLIENT_SECRET

final String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.CLIENT_SECRET = "clientSecret"

staticprivate

configurationFactory

ConfigurationFactory org.gluu.oxtrust.action.ManagePersonAuthenticationAction.configurationFactory

private

conversationService

ConversationService org.gluu.oxtrust.action.ManagePersonAuthenticationAction.conversationService

private

customAuthenticationConfigNames

List<String> org.gluu.oxtrust.action.ManagePersonAuthenticationAction.customAuthenticationConfigNames

private

customScripts

List<CustomScript> org.gluu.oxtrust.action.ManagePersonAuthenticationAction.customScripts

private

customScriptService

AbstractCustomScriptService org.gluu.oxtrust.action.ManagePersonAuthenticationAction.customScriptService

private

encryptionService

EncryptionService org.gluu.oxtrust.action.ManagePersonAuthenticationAction.encryptionService

private

existLdapConfigIdpAuthConf

boolean org.gluu.oxtrust.action.ManagePersonAuthenticationAction.existLdapConfigIdpAuthConf

private

facesMessages

FacesMessages org.gluu.oxtrust.action.ManagePersonAuthenticationAction.facesMessages

private

initialized

boolean org.gluu.oxtrust.action.ManagePersonAuthenticationAction.initialized

private

jsonConfigurationService

JsonConfigurationService org.gluu.oxtrust.action.ManagePersonAuthenticationAction.jsonConfigurationService

private

ldapOxPassportConfiguration

LdapOxPassportConfiguration org.gluu.oxtrust.action.ManagePersonAuthenticationAction.ldapOxPassportConfiguration

private

ldapPassportConfigurations

List<PassportConfiguration> org.gluu.oxtrust.action.ManagePersonAuthenticationAction.ldapPassportConfigurations

private

log

Logger org.gluu.oxtrust.action.ManagePersonAuthenticationAction.log

private

oxTrustappConfiguration

AppConfiguration org.gluu.oxtrust.action.ManagePersonAuthenticationAction.oxTrustappConfiguration

private

oxTrustAuthenticationMode

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.oxTrustAuthenticationMode

private

passportEnable

GluuBoolean org.gluu.oxtrust.action.ManagePersonAuthenticationAction.passportEnable = GluuBoolean.DISABLED

private

passportService

PassportService org.gluu.oxtrust.action.ManagePersonAuthenticationAction.passportService

private

recaptchaSecretKey

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.recaptchaSecretKey

private

recaptchaSiteKey

String org.gluu.oxtrust.action.ManagePersonAuthenticationAction.recaptchaSiteKey

private

serialVersionUID

final long org.gluu.oxtrust.action.ManagePersonAuthenticationAction.serialVersionUID = -4470460481895022468L

staticprivate

sourceConfigs

List<GluuLdapConfiguration> org.gluu.oxtrust.action.ManagePersonAuthenticationAction.sourceConfigs

private

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/gluu/src/oxTrust/server/src/main/java/org/gluu/oxtrust/action/ManagePersonAuthenticationAction.java