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

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

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

公開メンバ関数
String	getEmail ()
void	setEmail (String email)
String	initPerson ()
String	initPersonImpl ()
String	register () throws CloneNotSupportedException
String	registerImpl () throws CloneNotSupportedException
void	confirm ()
String	cancel ()
List< GluuCustomAttribute >	getMandatoryAttributes ()
List< GluuCustomAttribute >	getCustomAttributes ()
GluuCustomPerson	getPerson ()
String	getInum ()
void	setInum (String inum)
List< String >	getHiddenAttributes ()
String	getPassword ()
void	setPassword (String password)
String	getRepeatPassword ()
void	setRepeatPassword (String repeatPassword)
boolean	isCaptchaDisabled ()
String	getPostRegistrationInformation ()
void	validateEmail (FacesContext context, UIComponent component, Object value) throws ValidatorException

限定公開メンバ関数
String	getActionName ()
String	getEventQueue ()

非公開メンバ関数
String	sanityCheck ()
void	initRecaptcha ()
void	initAttributes ()

非公開変数類
Logger	log
AttributeService	attributeService
OrganizationService	organizationService
CustomAttributeAction	customAttributeAction
FacesMessages	facesMessages
ConversationService	conversationService
ExternalUserRegistrationService	externalUserRegistrationService
GluuCustomPerson	person
IPersonService	personService
Identity	identity
OxTrustAuditService	oxTrustAuditService
String	password
String	repeatPassword
String	email
AppConfiguration	appConfiguration
RecaptchaService	recaptchaService
List< String >	hiddenAttributes
String	inum
Map< String, String[]>	requestParameters = new HashMap<String, String[]>()
boolean	captchaDisabled = false
String	postRegistrationInformation

静的非公開変数類
static final long	serialVersionUID = 6002737004324917338L

詳解

著者

Dejan Maric

Yuriy Movchan Date: 08.14.2015

関数詳解

cancel()

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

inline

                               {
                facesMessages.add(FacesMessage.SEVERITY_INFO, "You didn't register.");
                conversationService.endConversation();

                return OxTrustConstants.RESULT_SUCCESS;
        }

confirm()

void org.gluu.oxtrust.action.RegisterPersonAction.confirm ( )

inline

                              {
                HttpServletRequest request = (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext()
                                .getRequest();
                String code = request.getParameter("code");
                requestParameters.put("code", new String[] { code });
                try {
                        boolean result = externalUserRegistrationService.executeExternalConfirmRegistrationMethods(this.person,
                                        requestParameters);
                } catch (Exception ex) {
                        log.error("Failed to confirm registration.", ex);
                }
        }

getActionName()

String org.gluu.oxtrust.action.RegisterPersonAction.getActionName ( )

inlineprotected

                                         {
                return "registerPersonAction";
        }

getCustomAttributes()

List<GluuCustomAttribute> org.gluu.oxtrust.action.RegisterPersonAction.getCustomAttributes ( )

inline

Returns person's attributes

戻り値

list of person's attributes

                                                               {
                return this.person.getCustomAttributes();
        }

getEmail()

String org.gluu.oxtrust.action.RegisterPersonAction.getEmail ( )

inline

                                 {
                return email;
        }

getEventQueue()

String org.gluu.oxtrust.action.RegisterPersonAction.getEventQueue ( )

inlineprotected

                                         {
                return "personQueue";
        }

getHiddenAttributes()

List<String> org.gluu.oxtrust.action.RegisterPersonAction.getHiddenAttributes ( )

inline

                                                  {
                return hiddenAttributes;
        }

getInum()

String org.gluu.oxtrust.action.RegisterPersonAction.getInum ( )

inline

                                {
                return inum;
        }

getMandatoryAttributes()

List<GluuCustomAttribute> org.gluu.oxtrust.action.RegisterPersonAction.getMandatoryAttributes ( )

inline

Returns list of mandatory attributes

戻り値

list of person's mandatory attributes

例外

Exception

                                                                  {
                return personService.getMandatoryAtributes();
        }

getPassword()

String org.gluu.oxtrust.action.RegisterPersonAction.getPassword ( )

inline

                                    {
                return password;
        }

getPerson()

GluuCustomPerson org.gluu.oxtrust.action.RegisterPersonAction.getPerson ( )

inline

                                            {
                return person;
        }

getPostRegistrationInformation()

String org.gluu.oxtrust.action.RegisterPersonAction.getPostRegistrationInformation ( )

inline

                                                       {
                return postRegistrationInformation;
        }

getRepeatPassword()

String org.gluu.oxtrust.action.RegisterPersonAction.getRepeatPassword ( )

inline

                                          {
                return repeatPassword;
        }

initAttributes()

void org.gluu.oxtrust.action.RegisterPersonAction.initAttributes ( )

inlineprivate

                                      {
                List<GluuAttribute> allPersonAttributes = attributeService.getAllActivePersonAttributes(UserRole.ADMIN);

                List<String> allAttributOrigins = attributeService.getAllAttributeOrigins(allPersonAttributes);

                GluuOrganization organization = organizationService.getOrganization();

                List<GluuCustomAttribute> customAttributes = this.person.getCustomAttributes();

                boolean isNewPerson = (customAttributes == null) || customAttributes.isEmpty();

                if (isNewPerson) {
                        customAttributes = new ArrayList<GluuCustomAttribute>();
                        this.person.setCustomAttributes(customAttributes);
                }

                String[] personOCs = appConfiguration.getPersonObjectClassTypes();
                String[] personOCDisplayNames = appConfiguration.getPersonObjectClassDisplayNames();
                customAttributeAction.initCustomAttributes(allPersonAttributes, customAttributes, allAttributOrigins, personOCs,
                                personOCDisplayNames);

                List<GluuCustomAttribute> mandatoryAttributes = new ArrayList<GluuCustomAttribute>();

                RegistrationConfiguration config = organization.getOxRegistrationConfiguration();
                boolean registrationCustomized = config != null;
                boolean registrationAttributesCustomized = registrationCustomized && config.getAdditionalAttributes() != null
                                && !config.getAdditionalAttributes().isEmpty();

                if (registrationAttributesCustomized) {
                        for (String attributeInum : config.getAdditionalAttributes()) {
                                GluuAttribute attribute = attributeService.getAttributeByInum(attributeInum);
                                GluuCustomAttribute customAttribute = new GluuCustomAttribute(attribute.getName(), "", false, false);
                                mandatoryAttributes.add(customAttribute);
                        }
                }
                for (GluuCustomAttribute attribute : personService.getMandatoryAtributes()) {
                        if (!mandatoryAttributes.contains(attribute)) {
                                mandatoryAttributes.add(attribute);
                        }
                }
                mandatoryAttributes.addAll(personService.getMandatoryAtributes());

                if (isNewPerson) {
                        customAttributeAction.addCustomAttributes(mandatoryAttributes);
                }

                hiddenAttributes = new ArrayList<String>();
                hiddenAttributes.add("inum");
                hiddenAttributes.add("iname");
                hiddenAttributes.add("userPassword");
                hiddenAttributes.add("gluuStatus");
                hiddenAttributes.add("oxExternalUid");
                hiddenAttributes.add("oxLastLogonTime");
        }

initPerson()

String org.gluu.oxtrust.action.RegisterPersonAction.initPerson ( )

inline

Initializes attributes for registering new person

戻り値

String describing success of the operation

例外

Exception

                                   {
                String outcome = initPersonImpl();

                if (OxTrustConstants.RESULT_FAILURE.equals(outcome)) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                        "You cannot enter this page. Please contact site administration.");
                        conversationService.endConversation();
                } else if (OxTrustConstants.RESULT_NO_PERMISSIONS.equals(outcome)) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                        "Failed to execute registration script. Please contact site administration.");
                        conversationService.endConversation();
                }

                return outcome;
        }

initPersonImpl()

String org.gluu.oxtrust.action.RegisterPersonAction.initPersonImpl ( )

inline

                                       {
                initRecaptcha();

                String result = sanityCheck();
                if (result.equals(OxTrustConstants.RESULT_SUCCESS)) {

                        if (!externalUserRegistrationService.isEnabled()) {
                                return OxTrustConstants.RESULT_NO_PERMISSIONS;
                        }

                        this.person = (inum == null || inum.isEmpty()) ? new GluuCustomPerson()
                                        : personService.getPersonByInum(inum);

                        boolean isPersonActiveOrDisabled = GluuStatus.ACTIVE.equals(person.getStatus())
                                        || GluuStatus.INACTIVE.equals(person.getStatus());

                        if (isPersonActiveOrDisabled) {
                                result = OxTrustConstants.RESULT_NO_PERMISSIONS;
                        } else {
                                initAttributes();
                                boolean initScriptResult = externalUserRegistrationService
                                                .executeExternalInitRegistrationMethods(this.person, requestParameters);
                                result = initScriptResult ? OxTrustConstants.RESULT_SUCCESS : OxTrustConstants.RESULT_FAILURE;
                        }
                }

                return result;
        }

initRecaptcha()

void org.gluu.oxtrust.action.RegisterPersonAction.initRecaptcha ( )

inlineprivate

                                     {
                GluuOrganization organization = organizationService.getOrganization();
                RegistrationConfiguration config = organization.getOxRegistrationConfiguration();
                boolean registrationCustomized = config != null;

                this.captchaDisabled = !recaptchaService.isEnabled();
                if (!this.captchaDisabled) {
                        this.captchaDisabled = registrationCustomized && config.isCaptchaDisabled();
                }
        }

isCaptchaDisabled()

boolean org.gluu.oxtrust.action.RegisterPersonAction.isCaptchaDisabled ( )

inline

                                           {
                return captchaDisabled;
        }

register()

String org.gluu.oxtrust.action.RegisterPersonAction.register ( ) throws CloneNotSupportedException

inline

                                                                   {
                String outcome = registerImpl();

                if (OxTrustConstants.RESULT_SUCCESS.equals(outcome)) {
                        facesMessages.add(FacesMessage.SEVERITY_INFO, "You successfully registered.");
                        conversationService.endConversation();
                } else if (OxTrustConstants.RESULT_DISABLED.equals(outcome)) {
                        facesMessages.add(FacesMessage.SEVERITY_INFO, "You successfully registered. But your account is disabled.");
                        conversationService.endConversation();
                } else if (OxTrustConstants.RESULT_FAILURE.equals(outcome)) {
                        log.error(
                                        "Failed to register new user. Please make sure you are not registering a duplicate account or try another username.");
                        facesMessages.add(FacesMessage.SEVERITY_ERROR,
                                        "Failed to register new user. Please make sure you are not registering a duplicate account or try another username.");
                } else if (OxTrustConstants.RESULT_CAPTCHA_VALIDATION_FAILED.equals(outcome)) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Captcha validation failed. Please try again.");
                }

                return outcome;
        }

registerImpl()

String org.gluu.oxtrust.action.RegisterPersonAction.registerImpl ( ) throws CloneNotSupportedException

inline

                                                                       {
                boolean registrationFormValid = StringHelper.equals(password, repeatPassword);

                if (!captchaDisabled) {
                        String gRecaptchaRresponse = FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap()
                                        .get("g-recaptcha-response");
                        boolean reCaptchaResponse = recaptchaService.verifyRecaptchaResponse(gRecaptchaRresponse);
                        registrationFormValid &= reCaptchaResponse;
                }

                if (registrationFormValid) {
                        GluuCustomPerson archivedPerson = (GluuCustomPerson) person.clone();

                        String customObjectClass = attributeService.getCustomOrigin();

                        this.person.setCustomObjectClasses(new String[] { customObjectClass });

                        // Save person
                        if (person.getInum() == null) {
                                String inum = personService.generateInumForNewPerson();
                                this.person.setInum(inum);
                        }

                        if (person.getIname() == null) {
                                String iname = personService.generateInameForNewPerson(this.person.getUid());
                                this.person.setIname(iname);
                        }

                        if (person.getDn() == null) {
                                String dn = personService.getDnForPerson(this.person.getInum());
                                this.person.setDn(dn);
                        }

                        List<GluuCustomAttribute> personAttributes = this.person.getCustomAttributes();
                        if (!personAttributes.contains(new GluuCustomAttribute("cn", ""))) {
                                List<GluuCustomAttribute> changedAttributes = new ArrayList<GluuCustomAttribute>();
                                changedAttributes.addAll(personAttributes);
                                changedAttributes.add(
                                                new GluuCustomAttribute("cn", this.person.getGivenName() + " " + this.person.getSurname()));
                                this.person.setCustomAttributes(changedAttributes);
                        } else {
                                this.person.setCommonName(this.person.getCommonName());
                        }
                        // save password
                        this.person.setUserPassword(password);
                        this.person.setCreationDate(new Date());
                        this.person.setMail(email);

                        try {
                                // Set default message
                                this.postRegistrationInformation = "You have successfully registered with oxTrust. Login to begin your session.";

                                boolean result = false;
                                result = externalUserRegistrationService.executeExternalPreRegistrationMethods(this.person,
                                                requestParameters);
                                if (!result) {
                                        this.person = archivedPerson;
                                        return OxTrustConstants.RESULT_FAILURE;
                                }
                                if ((this.inum != null) && !this.inum.isEmpty()) {
                                        personService.updatePerson(this.person);
                                        try {
                                                oxTrustAuditService.audit(
                                                                this.person.getInum() + " **" + this.person.getDisplayName()
                                                                                + "** REGISTRATION UPDATED",
                                                                identity.getUser(), (HttpServletRequest) FacesContext.getCurrentInstance()
                                                                                .getExternalContext().getRequest());
                                        } catch (Exception e) {
                                        }

                                } else {
                                        personService.addPerson(this.person);
                                        try {
                                                oxTrustAuditService.audit(
                                                                this.person.getInum() + " **" + this.person.getDisplayName() + "** REGISTERED",
                                                                identity.getUser(), (HttpServletRequest) FacesContext.getCurrentInstance()
                                                                                .getExternalContext().getRequest());
                                        } catch (Exception e) {
                                        }
                                }

                                result = externalUserRegistrationService.executeExternalPostRegistrationMethods(this.person,
                                                requestParameters);

                                if (!result) {
                                        this.person = archivedPerson;
                                        return OxTrustConstants.RESULT_FAILURE;
                                }

                                if (GluuStatus.INACTIVE.equals(person.getStatus())) {
                                        return OxTrustConstants.RESULT_DISABLED;
                                }
                        } catch (Exception ex) {
                                log.error("Failed to add new person {}", this.person.getInum(), ex);
                                facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to add new person");
                                this.person = archivedPerson;
                                return OxTrustConstants.RESULT_FAILURE;
                        }
                        return OxTrustConstants.RESULT_SUCCESS;
                }

                return OxTrustConstants.RESULT_CAPTCHA_VALIDATION_FAILED;
        }

sanityCheck()

String org.gluu.oxtrust.action.RegisterPersonAction.sanityCheck ( )

inlineprivate

Checks if session is correct for person registration.

戻り値

OxTrustConstants constant to be returned by action

                                     {
                if (this.person != null) {
                        return OxTrustConstants.RESULT_SUCCESS;
                }

                requestParameters.putAll(FacesContext.getCurrentInstance().getExternalContext().getRequestParameterValuesMap());

                return OxTrustConstants.RESULT_SUCCESS;

        }

setEmail()

void org.gluu.oxtrust.action.RegisterPersonAction.setEmail ( String  email )

inline

                                           {
                this.email = email;
        }

setInum()

void org.gluu.oxtrust.action.RegisterPersonAction.setInum ( String  inum )

inline

                                         {
                this.inum = inum;
        }

setPassword()

void org.gluu.oxtrust.action.RegisterPersonAction.setPassword ( String  password )

inline

                                                 {
                this.password = password;
        }

setRepeatPassword()

void org.gluu.oxtrust.action.RegisterPersonAction.setRepeatPassword ( String  repeatPassword )

inline

                                                             {
                this.repeatPassword = repeatPassword;
        }

validateEmail()

void org.gluu.oxtrust.action.RegisterPersonAction.validateEmail ( FacesContext  context, UIComponent  component, Object  value  ) throws ValidatorException

inline

                                                                                                                       {
                String email = (String) value;

                if ((email == null) || (email.trim().equals(""))) {
                        FacesMessage message = new FacesMessage("Please Enter Your Email Address.");
                        message.setSeverity(FacesMessage.SEVERITY_ERROR);
                        throw new ValidatorException(message);
                }

                Pattern pattern = Pattern.compile(
                                "^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@" + "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$");
                Matcher matcher = pattern.matcher(email);

                if (!(matcher.matches())) {
                        FacesMessage message = new FacesMessage("Please Enter Valid Email Address.");
                        message.setSeverity(FacesMessage.SEVERITY_ERROR);
                        throw new ValidatorException(message);

                }

                GluuCustomPerson gluuCustomPerson = personService.getPersonByEmail(email);
                if (gluuCustomPerson != null) {
                        FacesMessage message = new FacesMessage("Email Address Already Registered.");
                        message.setSeverity(FacesMessage.SEVERITY_ERROR);
                        throw new ValidatorException(message);
                }
        }

メンバ詳解

appConfiguration

AppConfiguration org.gluu.oxtrust.action.RegisterPersonAction.appConfiguration

private

attributeService

AttributeService org.gluu.oxtrust.action.RegisterPersonAction.attributeService

private

captchaDisabled

boolean org.gluu.oxtrust.action.RegisterPersonAction.captchaDisabled = false

private

conversationService

ConversationService org.gluu.oxtrust.action.RegisterPersonAction.conversationService

private

customAttributeAction

CustomAttributeAction org.gluu.oxtrust.action.RegisterPersonAction.customAttributeAction

private

email

String org.gluu.oxtrust.action.RegisterPersonAction.email

private

externalUserRegistrationService

ExternalUserRegistrationService org.gluu.oxtrust.action.RegisterPersonAction.externalUserRegistrationService

private

facesMessages

FacesMessages org.gluu.oxtrust.action.RegisterPersonAction.facesMessages

private

hiddenAttributes

List<String> org.gluu.oxtrust.action.RegisterPersonAction.hiddenAttributes

private

identity

Identity org.gluu.oxtrust.action.RegisterPersonAction.identity

private

inum

String org.gluu.oxtrust.action.RegisterPersonAction.inum

private

log

Logger org.gluu.oxtrust.action.RegisterPersonAction.log

private

organizationService

OrganizationService org.gluu.oxtrust.action.RegisterPersonAction.organizationService

private

oxTrustAuditService

OxTrustAuditService org.gluu.oxtrust.action.RegisterPersonAction.oxTrustAuditService

private

password

String org.gluu.oxtrust.action.RegisterPersonAction.password

private

person

GluuCustomPerson org.gluu.oxtrust.action.RegisterPersonAction.person

private

personService

IPersonService org.gluu.oxtrust.action.RegisterPersonAction.personService

private

postRegistrationInformation

String org.gluu.oxtrust.action.RegisterPersonAction.postRegistrationInformation

private

recaptchaService

RecaptchaService org.gluu.oxtrust.action.RegisterPersonAction.recaptchaService

private

repeatPassword

String org.gluu.oxtrust.action.RegisterPersonAction.repeatPassword

private

requestParameters

Map<String, String[]> org.gluu.oxtrust.action.RegisterPersonAction.requestParameters = new HashMap<String, String[]>()

private

serialVersionUID

final long org.gluu.oxtrust.action.RegisterPersonAction.serialVersionUID = 6002737004324917338L

staticprivate

---

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

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