userregistrationformsubmitaction.java

开源的OpenId的一个java实现

/*
 * Copyright 2004,2005 The Apache Software Foundation. Licensed under the Apache
 * License, Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law
 * or agreed to in writing, software distributed under the License is
 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */

package org.wso2.solutions.identity.user.ui.action;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts2.StrutsStatics;
import org.wso2.solutions.identity.IdentityConstants;
import org.wso2.solutions.identity.IdentityProviderConstants;
import org.wso2.solutions.identity.IdentityProviderException;
import org.wso2.solutions.identity.UserStore;
import org.wso2.solutions.identity.admin.ClaimsAdmin;
import org.wso2.solutions.identity.admin.ParameterAdmin;
import org.wso2.solutions.identity.admin.ReportAdmin;
import org.wso2.solutions.identity.openid.OpenIDProvider;
import org.wso2.solutions.identity.openid.OpenIDUtil;
import org.wso2.solutions.identity.persistence.dataobject.ActionDO;
import org.wso2.solutions.identity.persistence.dataobject.ClaimDO;
import org.wso2.solutions.identity.relyingparty.RelyingPartyException;
import org.wso2.solutions.identity.user.ui.util.UserUtil;
import org.wso2.usermanager.UserManagerException;
import org.wso2.usermanager.UserStoreAdmin;
import org.wso2.usermanager.verification.email.EmailVerifier;

import javax.servlet.http.HttpServletRequest;

import java.util.HashMap;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.validator.annotations.RequiredStringValidator;
import com.opensymphony.xwork2.validator.annotations.Validation;

@Validation
public class UserRegistrationFormSubmitAction extends ManagedAction {

    private static final long serialVersionUID = -4791453858953047850L;

    private String username;
    private String password;
    private String retypedPassword;

    private static Log log = LogFactory
            .getLog(UserRegistrationFormSubmitAction.class);

    public String execute() throws Exception {
        UserStore store = UserStore.getInstance();

        ClaimsAdmin ClaimsAdmin = new ClaimsAdmin();
        ClaimDO[] claimDOs = ClaimsAdmin.getAllMappedEnabledClaims();
        HttpServletRequest request = (HttpServletRequest) ActionContext
                .getContext().get(StrutsStatics.HTTP_REQUEST);

        if (!password.equals(retypedPassword)) {
            this.addErrorMessage("Password mismatch");
            return ERROR;
        }

        String emailAddress = null;
        HashMap<String, String> props = new HashMap<String, String>();
        for (int i = 0; i < claimDOs.length; i++) {
            String uri = claimDOs[i].getUri();
            if (!uri.equals(IdentityConstants.CLAIM_PPID)) {

                if (claimDOs[i].isRequired()
                        && (request.getParameter(uri) == null || request
                                .getParameter(uri).trim().length() == 0)) {
                    this.addErrorMessage(getText("required_feilds_missing"));
                    return ERROR;
                }

                if (request.getParameter(uri) != null
                        && request.getParameter(uri).trim().length() > 0)
                    props.put(uri, request.getParameter(uri));
            }

            if (uri.equals(IdentityConstants.CLAIM_EMAIL_ADDRESS)) {
                emailAddress = request.getParameter(uri);
            }
        }

        ParameterAdmin paramAdmin = new ParameterAdmin();
        boolean enableOpenIDRegistration = paramAdmin
                .getParameter(IdentityProviderConstants.PARAM_NAME_ENABLE_OPENID_REGISTRATION) != null;

        String openid = null;

        if (enableOpenIDRegistration) {
            try {
                // We create an OpenID for all registering users
                openid = OpenIDUtil.generateOpenID(this.username);
                UserUtil.getUserName(openid);
                this.addErrorMessage(getText("sign_in_user_exist",
                        new String[] { username }));
                return ERROR;                
            } catch (RelyingPartyException e) {
                // There are no users corresponding to the given OpenID
                props.put(IdentityConstants.CLAIM_OPENID, openid);                
            } catch (IdentityProviderException ex) {
                this.addErrorMessage(getText("invalid_user_name"));
                return ERROR;
            }                        
        }

        boolean emailVerification = paramAdmin
                .getParameter(IdentityProviderConstants.PARAM_NAME_ENABLE_EMAIL_VERIFICATION) != null;
        if (emailVerification && emailAddress != null) {
            try {
                EmailVerifier verifier = new EmailVerifier();
                verifier.requestUserVerification(username, emailAddress,
                        password, props);
                String msg = getText("email_verification",
                        new String[] { username });
                ReportAdmin
                        .record(username, ActionDO.ACTION_USER_REGISTER, msg);
                this.addInfoMessage(getText("please_check_mail",
                        new String[] { emailAddress }));
            } catch (UserManagerException e) {
                String msg = getText("error_unexpected", new String[] { e
                        .getMessage() });
                this.addErrorMessage(msg);
                log.error(msg, e);
                return ERROR;
            }
        } else {
            try {
                UserStoreAdmin umAdmin = store.getRealm().getUserStoreAdmin();
                if (umAdmin.isExistingUser(username)) {
                    this.addErrorMessage(getText("sign_in_user_exist",
                            new String[] { username }));
                    loadMessages();
                    return ERROR;
                } else {
                    umAdmin.addUser(this.username, this.password);
                }

            } catch (UserManagerException e) {
                String msg = getText("error_unexpected", new String[] { e
                        .getMessage() });
                this.addErrorMessage(msg);
                log.error(msg, e);
                return ERROR;
            }

            store.getRealm().getUserStoreAdmin().setUserProperties(
                    this.username, props);
            String msg = getText("successful_for", new String[] { username });
            ReportAdmin.record(username, ActionDO.ACTION_USER_REGISTER, msg);

            this.addInfoMessage(getText("user_successfully_added",
                    new String[] { username }));

            if (enableOpenIDRegistration) {
                this.addInfoMessage("Your OpenID is " + openid);
            }
        }

        return SUCCESS;
    }

    @RequiredStringValidator(message = "", key = "username")
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @RequiredStringValidator(message = "", key = "password")
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @RequiredStringValidator(message = "", key = "retypedPassword")
    public String getRetypedPassword() {
        return retypedPassword;
    }

    public void setRetypedPassword(String retypedPassword) {
        this.retypedPassword = retypedPassword;
    }

}