Z-Archive » Maybank Projects » M2U UPASS Project

package my.com.upass;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.Date;

import java.util.HashMap;

import my.com.upass.db.DBOperations;

import my.com.upass.factory.UPassFactory;

import my.com.upass.pojo.MinimalUserBean;

import my.com.upass.pojo.TacBean;

import my.com.upass.pojo.UserBean;

import my.com.upass.spassword.PasswordController;

import my.com.upass.vasco.LoadTokenDPX;

import my.com.upass.vasco.TokenController;

//import com.vasco.utils.DigipassInfo;

/**

 * @author LeeTK dking

 *         UPassController Class Release 20090703

 *

 */

public class UPassController extends MinimalUPassController {

        // private UserBean userBean = null;

        // private TacBean tacBean = null;

        long userID;

        /**

         * Constructs an empty object

         */

        public UPassController() {

                getSystemProperties();

                logger.info("Constructor::UPassController()");

        }

        /**

         * Constructs an object contains the initial userAlias value

         *

         * @param userAlias

         */

        public UPassController(String userAlias) {

                getSystemProperties();

                logger.info("Constructor::UPassController(" + userAlias + ")");

                setUserAlias(userAlias);

        }

        /**

         * Sets the userAlias with this binding.

         *

         * @param userAlias

         */

        public void setUserAlias(String userAlias) {

                this.userAlias = userAlias;

        }

        private void getSystemProperties() {

                Config cfg = Config.getInstance();

                try {

                        SUPERVISOR_ID_SUSPEND = Integer.parseInt(cfg.get("SUPERVISOR_ID_SUSPEND").toString());

                        _MAX_ERROR = Integer.parseInt(cfg.get("PASSWORD_MAX_ERROR").toString());

                } catch (Exception e) {

                        logger.error(e.toString(), e);

                }

        }

        // /////////////////////////////////////////////////////////////////////////////////////////

        // Static Password Methods

        // /////////////////////////////////////////////////////////////////////////////////////////

        /**

         * This method verify static password generated using SP_ChangeStaticPassword().

         *

         * @param userAlias

         * @param password

         * @return ERR_code defined in the Constants.<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND <br/>

         *         ERR_INVALID_STATE - user not active or temporary suspended.<br/>

         *         ERR_APP_SERV_NOT_PERMITTED - for operation not allowed for the user type.<br/>

         *         ERR_EXCEED_MAX_TRIES - used ModifyUser to reset password.<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         *         ERR_PASSWD_EXPIRED - password is valid but expired, suggest to change new password.<br/>

         */

        public int SP_VerifyStaticPassword(String userAlias, String password) {

                int rc = verifyStaticPassword(userAlias, password, false, 0);

                logger.info(userAlias + " Return=" + rc);

                return rc;

        }

        /**

         * This method generate static password and to be using SP_VerifyStaticPassword().

         *

         * @param userAlias

         * @param newPassword

         * @param oldPassword

         * @return ERR_code defined in the Constants<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND<br/>

         *         ERR_INVALID_STATE - user not active or temporary suspended.<br/>

         *         ERR_APP_SERV_NOT_PERMITTED - for operation not allowed for the user type.<br/>

         *         ERR_EXCEED_MAX_TRIES - used ModifyUser to reset password.<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         *         ERR_REUSED_PASSWD - reuse previous generated password.<br/>

         */

        public int SP_ChangeStaticPassword(String userAlias, String newPassword, String oldPassword) {

                int rc = changeStaticPassword(userAlias, newPassword, oldPassword);

                logger.info(userAlias + " Return=" + rc);

                return rc;

        }

        private int changeStaticPassword(String userAlias, String newHashedPassword, String oldHashedPassword) {

                DBOperations dbo = new DBOperations();

                MinimalUserBean userBean = new UserBean();

                userBean = dbo.getUserFromStore(userAlias);

                if (userBean == null) {

                        dbo.close();

                        return Constants.ERR_USERALIAS_NOT_FOUND;

                }

                // verify user

                PasswordController pc = new PasswordController(userBean);

                if (isInMigrationPeriod()) {

                        final String oldPlainPassword = oldHashedPassword;

                        final String newPlainPassword = newHashedPassword;

                        oldHashedPassword = PasswordController.sha256(oldPlainPassword);

                        newHashedPassword = PasswordController.sha256(newPlainPassword);

                }

                int rc = pc.verifyPassword(oldHashedPassword);

                if (rc == Constants.ERR_SUCCESS || rc == Constants.ERR_PASSWD_EXPIRED) {

                        rc = pc.generatePassword(newHashedPassword, true);

                }

                userBean = pc.getUpdatedObject();

                // Debug info:

                logger.debug("RC........." + rc +

                                "\n.use......." + userBean.getPuseCount() +

                                "\n.err......." + userBean.getPerrorCount() +

                                "\n.hist......" + userBean.getPhistoryList() +

                                "\n.last......" +

                                new String(Constants.defaultDateFormat.format(userBean.getPdateLastUsed())));

                // debug info:

                // update database

                boolean lrc = dbo.updateUserToStore(userBean);

                dbo.close();

                if (!lrc) {

                        rc = Constants.ERR_SYSTEM_NOT_READY;

                }

                return rc;

        }

        // /////////////////////////////////////////////////////////////////////////////////////////

        // User Administration methods.

        // /////////////////////////////////////////////////////////////////////////////////////////

        /**

         * This method to add online users to the system

         *

         * @param adminUserAlias

         * @param adminUserPassword

         * @param userAlias

         * @param userDesc

         * @param userPassword

         * @return ERR_code defined in the Constants<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND <br/>

         *         ERR_INVALID_STATE - admin not active or temporary suspended.<br/>

         *         ERR_APP_SERV_NOT_PERMITTED - for operation not allowed for the user type.<br/>

         *         ERR_EXCEED_MAX_TRIES<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         *         ERR_INVALID_INPUT - internal error.<br/>

         *         ERR_ALREADY_EXIST<br/>

         */

        public int UA_AddUser(String adminUserAlias, String adminUserPassword,

                        String userAlias, String userDesc, String userPassword) {

                int rc = ua_AddUser(adminUserAlias, adminUserPassword, userAlias, userDesc, userPassword);

                logger.info(adminUserAlias + " " + userAlias + " Return=" + rc);

                return rc;

        }

        private int ua_AddUser(String adminUserAlias, String adminUserPassword,

                        String userAlias, String userDesc, String userPassword) {

                // verify supervisor password

                int rc = verifyStaticPassword(adminUserAlias, adminUserPassword, true, Constants.UTYPE_STATE_ADMIN);

                if (rc != Constants.ERR_SUCCESS) {

                        return rc;

                }

                return addUser(userAlias, Constants.UTYPE_STATE_USER, userDesc, userPassword, Constants.UID_STATE_ACTIVE);

        }

        /**

         * This method to Modify online users to the system

         *

         * @param adminUserAlias

         * @param adminUserPassword

         * @param userAlias

         * @param userDesc

         *            - can be null - Null denotes no description will be modified.

         * @param userPassword

         *            - can be null - Null denotes no password will be modified.

         * @return ERR_code defined in the Constants<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND <br/>

         *         ERR_INVALID_STATE - admin not active or temporary suspended.<br/>

         *         ERR_APP_SERV_NOT_PERMITTED - for operation not allowed for the user type.<br/>

         *         ERR_EXCEED_MAX_TRIES<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         *         ERR_INVALID_INPUT - internal error.<br/>

         *         ERR_USERALIAS_NOT_FOUND<br/>

         *         ERR_REUSED_PASSWD - the password entered was used previously.<br/>

         */

        public int UA_ModifyUser(String adminUserAlias, String adminUserPassword,

                        String userAlias, String userDesc, String userPassword) {

                int rc = ua_ModifyUser(adminUserAlias, adminUserPassword, userAlias, userDesc, userPassword);

                logger.info(adminUserAlias + " " + userAlias + " Return=" + rc);

                return rc;

        }

        private int ua_ModifyUser(String adminUserAlias, String adminUserPassword,

                        String userAlias, String userDesc, String userPassword) {

                // verify supervisor password

                int rc = verifyStaticPassword(adminUserAlias, adminUserPassword, true, Constants.UTYPE_STATE_ADMIN);

                if (rc != Constants.ERR_SUCCESS) {

                        return rc;

                }

                return modifyUser(userAlias, Constants.UTYPE_STATE_USER, userDesc, userPassword, Constants.UID_STATE_ACTIVE);

        }

        /**

         * This method to modify admin users to the system

         *

         * @param rootAlias

         * @param rootPassword

         * @param adminUserAlias

         * @param adminDesc

         *            - can be null - Null denotes no description will be modified.

         * @param adminUserPassword

         *            - can be null - Null denotes no password will be modified.

         * @return ERR_code defined in the Constants.<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND <br/>

         *         ERR_INVALID_STATE - root not active or temporary suspended.<br/>

         *         ERR_APP_SERV_NOT_PERMITTED - for operation not allowed for the user type.<br/>

         *         ERR_EXCEED_MAX_TRIES<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         *         ERR_INVALID_INPUT - internal error.<br/>

         *         ERR_USERALIAS_NOT_FOUND<br/>

         *         ERR_REUSED_PASSWD - the password entered was used previously.<br/>

         *         ERR_PASSWD_WEAK - the password entered is too weak.<br/>

         */

        public int AD_ModifyUser(String rootAlias, String rootPassword,

                        String adminUserAlias, String adminDesc, String adminUserPassword) {

                int rc = ad_ModifyUser(rootAlias, rootPassword, adminUserAlias, adminDesc, adminUserPassword);

                logger.info(rootAlias + " " + adminUserAlias + " Return=" + rc);

                return rc;

        }

        private int ad_ModifyUser(String rootAlias, String rootPassword,

                        String adminUserAlias, String adminDesc, String adminUserPassword) {

                // verify supervisor password

                int rc = verifyStaticPassword(rootAlias, rootPassword, true, Constants.UTYPE_STATE_ROOT);

                if (rc != Constants.ERR_SUCCESS) {

                        return rc;

                }

                return modifyUser(adminUserAlias, Constants.UTYPE_STATE_ADMIN, adminDesc, adminUserPassword,

                                Constants.UID_STATE_ACTIVE);

        }

        // TODO: chg to public for testing purpose only

        private int modifyUser(

                        String userAlias, int userType, String userDesc, String userHashedPassword, int userState) {

                int rc;

                if (userAlias == null)

                        return Constants.ERR_INVALID_INPUT;

                // insert into DB

                DBOperations dbo = new DBOperations();

                MinimalUserBean ub = new UserBean();

                ub = dbo.getUserFromStore(userAlias);

                if (ub == null) {

                        dbo.close();

                        return Constants.ERR_USERALIAS_NOT_FOUND;

                }

                if (userHashedPassword != null) {

                        // Generate new paswword

                        PasswordController pc = new PasswordController(ub);

                        if(isInMigrationPeriod()) {

                                final String userPlainPassword = userHashedPassword;

                                userHashedPassword = PasswordController.sha256(userPlainPassword);

                        }

                        // rc = pc.GeneratePassword(userPassword, false); //disable password hist check 20081220

                        rc = pc.generatePassword(userHashedPassword, true);

                        if (rc != Constants.ERR_SUCCESS) {

                                dbo.close();

                                return rc;

                        }

                        ub = pc.getUpdatedObject();

                }

                if (userDesc != null) {

                        ub.setDescription(userDesc);

                }

                ub.setUserType(userType);

                ub.setUstate(userState);

                if (dbo.updateUserToStore(ub)) {

                        rc = Constants.ERR_SUCCESS;

                } else {

                        rc = Constants.ERR_UNKNOWN;

                }

                dbo.close();

                return rc;

        }

        /**

         * This method to change online users state to ACTIVE status.

         *

         * @param adminUserAlias

         * @param adminUserPassword

         * @param userAlias

         * @return ERR_code defined in the Constants.<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND <br/>

         *         ERR_INVALID_STATE - admin not active or temporary suspended.<br/>

         *         ERR_APP_SERV_NOT_PERMITTED - for operation not allowed for the user type.<br/>

         *         ERR_EXCEED_MAX_TRIES<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         *         ERR_USERALIAS_NOT_FOUND<br/>

         *         ERR_UNKNOWN <br/>

         */

        public int UA_ActivateUser(String adminUserAlias, String adminUserPassword, String userAlias) {

                int rc = ua_ActivateUser(adminUserAlias, adminUserPassword, userAlias);

                logger.info(adminUserAlias + " " + userAlias + " Return=" + rc);

                return rc;

        }

        private int ua_ActivateUser(String adminUserAlias, String adminUserPassword, String userAlias) {

                // verify supervisor password

                int rc = verifyStaticPassword(adminUserAlias, adminUserPassword, true, Constants.UTYPE_STATE_ADMIN);

                if (rc != Constants.ERR_SUCCESS) {

                        return rc;

                }

                return activateUser(userAlias);

        }

        /**

         * This method to change admin users state to ACTIVE status.

         *

         * @param rootAlias

         * @param rootPassword

         * @param adminUserAlias

         * @return ERR_code defined in the Constants.<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND <br/>

         *         ERR_INVALID_STATE - root not active or temporary suspended.<br/>

         *         ERR_APP_SERV_NOT_PERMITTED - for operation not allowed for the user type.<br/>

         *         ERR_EXCEED_MAX_TRIES<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         *         ERR_USERALIAS_NOT_FOUND<br/>

         *         ERR_UNKNOWN<br/>

         */

        public int AD_ActivateUser(String rootAlias, String rootPassword, String adminUserAlias) {

                int rc = ad_ActivateUser(rootAlias, rootPassword, adminUserAlias);

                logger.info(rootAlias + " " + adminUserAlias + " Return=" + rc);

                return rc;

        }

        private int ad_ActivateUser(String rootAlias, String rootPassword, String adminUserAlias) {

                // verify supervisor password

                int rc = verifyStaticPassword(rootAlias, rootPassword, true, Constants.UTYPE_STATE_ROOT);

                if (rc != Constants.ERR_SUCCESS) {

                        return rc;

                }

                return activateUser(adminUserAlias);

        }

        // TODO: chg to public for testing purpose only

        private int activateUser(String userAlias) {

                int rc;

                if (userAlias == null)

                        return Constants.ERR_INVALID_INPUT;

                DBOperations dbo = new DBOperations();

                MinimalUserBean ub = new UserBean();

                ub = dbo.getUserFromStore(userAlias);

                if (ub == null) {

                        dbo.close();

                        return Constants.ERR_USERALIAS_NOT_FOUND;

                }

                ub.setUstate(Constants.UID_STATE_ACTIVE);

                ub.setUdateLastActivated(new Date());

                if (dbo.updateUserToStore(ub)) {

                        rc = Constants.ERR_SUCCESS;

                }

                else {

                        rc = Constants.ERR_UNKNOWN;

                }

                dbo.close();

                return rc;

        }

        /**

         * This method is to check whether the user alias exist in the system.

         *

         * @param userAlias

         * @return ERR_code defined in the Constants.<br/>

         *         ERR_SUCCESS 0 - found<br/>

         *         ERR_USERALIAS_NOT_FOUND 6<br/>

         *         ERR_SYSTEM_NOT_READY 98<br/>

         */

        public int UA_IsUserExist(String userAlias) {

                DBOperations dbo = new DBOperations();

                MinimalUserBean ub = new UserBean();

                ub = dbo.getUserFromStore(userAlias);

                dbo.close();

                if (ub == null) {

                        return Constants.ERR_USERALIAS_NOT_FOUND;

                }

                return Constants.ERR_SUCCESS;

        }

        /**

         * This method is to get user type. Valid return is [0-root user | 1-admin user | 2-Ordinary User]

         *

         * @param userAlias

         * @return <br/>

         *         UTYPE_STATE_ROOT = 0<br/>

         *         UTYPE_STATE_ADMIN = 1<br/>

         *         UTYPE_STATE_USER = 2<br/>

         *         ERR_USERALIAS_NOT_FOUND = 6<br/>

         *         ERR_SYSTEM_NOT_READY = 98<br/>

         */

        public int UA_GetUserType(String userAlias) {

                DBOperations dbo = new DBOperations();

                MinimalUserBean ub = new UserBean();

                ub = dbo.getUserFromStore(userAlias);

                dbo.close();

                if (ub == null) {

                        return Constants.ERR_USERALIAS_NOT_FOUND;

                }

                return ub.getUserType();

        }

        /**

         * This method is to get user ID associated to user alias

         *

         * @param userAlias

         * @return userID or Zero if failed.

         */

        public long UA_GetUserIDByAlias(String userAlias) {

                DBOperations dbo = new DBOperations();

                MinimalUserBean ub = new UserBean();

                ub = dbo.getUserFromStore(userAlias);

                dbo.close();

                return (ub == null) ? 0 : ub.getUserID();

        }

        /**

         * This method is to get attributes associated to user. Return type is HashMap<String,String>

         * The object keys is as below:<br/>

         * RC - Return Code [always present]<br/>

         * RT - Return Code in Text [always present]<br/>

         * <br/>

         * The following data present only with the return is ERR_SUCCESS<br/>

         * Type - User Type [0-Root User] [1-Admin User] [2-Ordinary User][9-SysControl]<br/>

         * State - User State [0-Active] [1-Temporary Locked] [2-Locked] [3-Inactive] [4-Deleted]<br/>

         * Description - User Description<br/>

         * UseCount - Number of time the record being access<br/>

         * DateCreated - Created date<br/>

         * DateLastUsed - Last access of the record<br/>

         * DateLastActivated - Last activation of the record<br/>

         * DateLastLocked - Last date the user being locked<br/>

         * DateLockedFrom - last date the user being locked from<br/>

         * DateLockedTo - last date the user being locked to<br/>

         *

         * @param userAlias

         * @return HashMap

         */

        public HashMap<String, String> UA_GetUserData(String userAlias) {

                HashMap<String, String> map = new HashMap<String, String>();

                DBOperations dbo = new DBOperations();

                MinimalUserBean ub = new UserBean();

                ub = dbo.getUserFromStore(userAlias);

                dbo.close();

                if (ub == null) {

                        map.put("RC", new Integer(Constants.ERR_USERALIAS_NOT_FOUND).toString());

                        map.put("RT", "ERR_USERALIAS_NOT_FOUND");

                        return map;

                }

                // return Constants.ERR_SUCCESS;

                map.put("RC", new Integer(Constants.ERR_SUCCESS).toString());

                map.put("RT", "ERR_SUCCESS");

                map.put("Type", new Integer(ub.getUserType()).toString());

                map.put("State", new Integer(ub.getUstate()).toString());

                map.put("Description", ub.getDescription());

                map.put("UseCount", new Long(ub.getUuseCount()).toString());

                map.put("DateCreated", (ub.getUdateCreated() == null) ? "NULL" : ub.getUdateCreated().toString());

                map.put("DateLastUsed", (ub.getUdateLastUsed() == null) ? "NULL" : ub.getUdateLastUsed().toString());

                map.put("DateLastActivated", (ub.getUdateLastActivated() == null) ? "NULL" : ub.getUdateLastActivated()

                                .toString());

                map.put("DateLastLocked", (ub.getUdateLastLocked() == null) ? "NULL" : ub.getUdateLastLocked().toString());

                map.put("DateLockedFrom", (ub.getUdateLockedFrom() == null) ? "NULL" : ub.getUdateLockedFrom().toString());

                map.put("DateLockedTo", (ub.getUdateLockedTo() == null) ? "NULL" : ub.getUdateLockedTo().toString());

                return map;

        }

        /**

         * This method is to get attributes associated to password. Return type is HashMap<String,String>

         * The object keys is as below:<br/>

         * RC - Return Code [always present]<br/>

         * RT - Return Code in Text [always present]<br/>

         * <br/>

         * The following data present only with the return is ERR_SUCCESS<br/>

         * State - Password State [0-Enable] [1-Disable] [2-OneTime Use]<br/>

         * ExpiryStatus - Expiry Status [0-Will Expired][1-Never Expired]

         * UseCount - Number of time the record being access<br/>

         * ErrorCount - Number of time the password verified error<br/>

         * DateCreated - Created date<br/>

         * DateFirstUsed - First access of the password<br/>

         * DateLastUsed - Last access of the password<br/>

         * DatePasswdExpired - Expiry date of the password<br/>

         *

         * @param userAlias

         * @return HashMap

         */

        public HashMap<String, String> QueryPassword(String userAlias) {

                HashMap<String, String> map = new HashMap<String, String>();

                DBOperations dbo = new DBOperations();

                MinimalUserBean ub = new UserBean();

                ub = dbo.getUserFromStore(userAlias);

                dbo.close();

                if (ub == null) {

                        map.put("RC", new Integer(Constants.ERR_USERALIAS_NOT_FOUND).toString());

                        map.put("RT", "ERR_USERALIAS_NOT_FOUND");

                        return map;

                }

                // return Constants.ERR_SUCCESS;

                map.put("RC", new Integer(Constants.ERR_SUCCESS).toString());

                map.put("RT", "ERR_SUCCESS");

                map.put("State", new Integer(ub.getPstate()).toString());

                map.put("ExpiryStatus", new Integer(ub.getPexpiredStatus()).toString());

                map.put("UseCount", new Long(ub.getPuseCount()).toString());

                map.put("ErrorCount", new Integer(ub.getPerrorCount()).toString());

                map.put("DateCreated", (ub.getPdateCreated() == null) ? "NULL" : ub.getPdateCreated().toString());

                map.put("DateFirstUsed", (ub.getPdateFirstUsed() == null) ? "NULL" : ub.getPdateFirstUsed().toString());

                map.put("DateLastUsed", (ub.getPdateLastUsed() == null) ? "NULL" : ub.getPdateLastUsed().toString());

                map.put("DatePasswdExpired", (ub.getPdateExpired() == null) ? "NULL" : ub.getPdateExpired().toString());

                return map;

        }

        /**

         * This method is to get attributes associated to TAC. Return type is HashMap<String,String>

         * The object keys is as below:<br/>

         * RC - Return Code [always present]<br/>

         * RT - Return Code in Text [always present]<br/>

         * <br/>

         * The following data present only with the return is ERR_SUCCESS<br/>

         * State - User State [0-Enable] [1-Disable]<br/>

         * UseCount - Number of time the record being access<br/>

         * ErrorCount - Number of time the TAC verified error<br/>

         * DateCreated - TAC Created date<br/>

         * DateFirstUsed - First access of the TAC<br/>

         * DateLastUsed - Last access of the TAC<br/>

         *

         * @param userAlias

         * @return HashMap

         */

        public HashMap<String, String> QueryTAC(String userAlias) {

                HashMap<String, String> map = new HashMap<String, String>();

                DBOperations dbo = new DBOperations();

                TacBean tacBean = new TacBean();

                tacBean = dbo.getTacFromStore(userAlias);

                dbo.close();

                if (tacBean == null) {

                        map.put("RC", new Integer(Constants.ERR_USERALIAS_NOT_FOUND).toString());

                        map.put("RT", "ERR_USERALIAS_NOT_FOUND");

                        return map;

                }

                // return Constants.ERR_SUCCESS;

                map.put("RC", new Integer(Constants.ERR_SUCCESS).toString());

                map.put("RT", "ERR_SUCCESS");

                map.put("State", new Integer(tacBean.getState()).toString());

                map.put("UseCount", new Integer(tacBean.getUseCount()).toString());

                map.put("ErrorCount", new Integer(tacBean.getErrorCount()).toString());

                map.put("DateCreated", (tacBean.getDateCreated() == null) ? "NULL" : tacBean.getDateCreated().toString());

                map.put("DateFirstUsed", (tacBean.getDateFirstUsed() == null) ? "NULL" : tacBean.getDateFirstUsed().toString());

                map.put("DateLastUsed", (tacBean.getDateLastUsed() == null) ? "NULL" : tacBean.getDateLastUsed().toString());

                map.put("SessionID", (tacBean.getSessionId() == null) ? "NULL" : tacBean.getSessionId());

                return map;

        }

        /**

         * This method is to change online user state to LOCKED status.

         *

         * @param adminUserAlias

         * @param adminUserPassword

         * @param userAlias

         * @return ERR_code defined in the Constants.<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND <br/>

         *         ERR_INVALID_STATE - admin not active or temporary suspended.<br/>

         *         ERR_APP_SERV_NOT_PERMITTED - for operation not allowed for the user type.<br/>

         *         ERR_EXCEED_MAX_TRIES<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         *         ERR_UNKNOWN<br/>

         */

        public int UA_LockUser(String adminUserAlias, String adminUserPassword, String userAlias) {

                int rc = ua_LockUser(adminUserAlias, adminUserPassword, userAlias);

                logger.info(adminUserAlias + " " + userAlias + " Return=" + rc);

                return rc;

        }

        private int ua_LockUser(String adminUserAlias, String adminUserPassword, String userAlias) {

                // verify supervisor password

                int rc = verifyStaticPassword(adminUserAlias, adminUserPassword, true, Constants.UTYPE_STATE_ADMIN);

                if (rc != Constants.ERR_SUCCESS) {

                        return rc;

                }

                return lockUser(userAlias);

        }

        /**

         * This method is to change admin user state to LOCKED status.

         *

         * @param rootAlias

         * @param rootPassword

         * @param adminUserAlias

         * @return ERR_code defined in the Constants.<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND <br/>

         *         ERR_INVALID_STATE - root not active or temporary suspended.<br/>

         *         ERR_APP_SERV_NOT_PERMITTED - for operation not allowed for the user type.<br/>

         *         ERR_EXCEED_MAX_TRIES<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         *         ERR_UNKNOWN<br/>

         */

        public int AD_LockUser(String rootAlias, String rootPassword, String adminUserAlias) {

                int rc = ad_LockUser(rootAlias, rootPassword, adminUserAlias);

                logger.info(rootAlias + " " + adminUserAlias + " Return=" + rc);

                return rc;

        }

        private int ad_LockUser(String rootAlias, String rootPassword, String adminUserAlias) {

                // verify supervisor password

                int rc = verifyStaticPassword(rootAlias, rootPassword, true, Constants.UTYPE_STATE_ROOT);

                if (rc != Constants.ERR_SUCCESS) {

                        return rc;

                }

                return lockUser(adminUserAlias);

        }

        /**

         * This method is to suspend online user from when for how many Minutes

         *

         * @param adminUserAlias

         * @param adminUserPassword

         * @param userAlias

         * @param fromDate

         *            - from when

         * @param nMinutes

         *            - Suspend for how many minutes

         * @return ERR_code defined in the Constants.<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND <br/>

         *         ERR_INVALID_STATE - admin not active or temporary suspended.<br/>

         *         ERR_APP_SERV_NOT_PERMITTED - for operation not allowed for the user type.<br/>

         *         ERR_EXCEED_MAX_TRIES<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         *         ERR_UNKNOWN<br/>

         */

        public int UA_SuspendUser(String adminUserAlias, String adminUserPassword, String userAlias, String strFromDate,

                        int nMinutes) {

                Date fromDate = StringToDate(strFromDate);

                int rc = ua_SuspendUser(adminUserAlias, adminUserPassword, userAlias, fromDate, nMinutes);

                logger.info(adminUserAlias + " " + userAlias + " From:" + fromDate + " for " + nMinutes + "min Return=" + rc);

                return rc;

        }

        private int ua_SuspendUser(String adminUserAlias, String adminUserPassword, String userAlias, Date fromDate,

                        int nMinutes) {

                // verify supervisor password

                int rc = verifyStaticPassword(adminUserAlias, adminUserPassword, true, Constants.UTYPE_STATE_ADMIN);

                if (rc != Constants.ERR_SUCCESS) {

                        return rc;

                }

                return lockUser(userAlias, Constants.UID_STATE_TMP_LOCKED, fromDate, nMinutes);

        }

        /**

         * This method is to suspend admin user from when for how many Minutes

         *

         * @param rootAlias

         * @param rootPassword

         * @param adminUserAlias

         * @param fromDate

         *            - from when

         * @param nMinutes

         *            - Suspend for how many Minutes

         * @return ERR_code defined in the Constants.<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND <br/>

         *         ERR_INVALID_STATE - root not active or temporary suspended.<br/>

         *         ERR_APP_SERV_NOT_PERMITTED - for operation not allowed for the user type.<br/>

         *         ERR_EXCEED_MAX_TRIES<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         *         ERR_UNKNOWN<br/>

         */

        public int AD_SuspendUser(String rootAlias, String rootPassword, String adminUserAlias, String strFromDate,

                        int nMinutes) {

                Date fromDate = StringToDate(strFromDate);

                int rc = ad_SuspendUser(rootAlias, rootPassword, adminUserAlias, fromDate, nMinutes);

                logger.info(userAlias + " Return=" + rc);

                return rc;

        }

        private int ad_SuspendUser(String rootAlias, String rootPassword, String adminUserAlias, Date fromDate, int nMinutes) {

                // verify supervisor password

                int rc = verifyStaticPassword(rootAlias, rootPassword, true, Constants.UTYPE_STATE_ROOT);

                if (rc != Constants.ERR_SUCCESS) {

                        return rc;

                }

                return lockUser(adminUserAlias, Constants.UID_STATE_TMP_LOCKED, fromDate, nMinutes);

        }

        private int lockUser(String userAlias) {

                return lockUser(userAlias, Constants.UID_STATE_LOCKED, null, 0);

        }

        private int lockUser(String userAlias, int mode, Date fromDate, int nMinutes) {

                int rc;

                if (userAlias == null)

                        return Constants.ERR_INVALID_INPUT;

                DBOperations dbo = new DBOperations();

                MinimalUserBean ub = new UserBean();

                ub = dbo.getUserFromStore(userAlias);

                if (ub == null) {

                        dbo.close();

                        return Constants.ERR_USERALIAS_NOT_FOUND;

                }

                Date now = new Date();

                if (mode == Constants.UID_STATE_LOCKED) {

                        ub.setUstate(Constants.UID_STATE_LOCKED);

                } else {

                        ub.setUstate(Constants.UID_STATE_TMP_LOCKED);

                        ub.setUdateLockedFrom(fromDate);

                        Calendar expiryDate = Calendar.getInstance();

                        expiryDate.setTime(fromDate); // set expiry date to fromDate

                        expiryDate.add(Calendar.MINUTE, +nMinutes);

                        ub.setUdateLockedTo(expiryDate.getTime());

                }

                ub.setUdateLastLocked(now);

                if (dbo.updateUserToStore(ub)) {

                        rc = Constants.ERR_SUCCESS;

                }

                else {

                        rc = Constants.ERR_UNKNOWN;

                }

                dbo.close();

                return rc;

        }

        // ///////////////////////////////////////////////////////////////////////////////

        // token area

        // ///////////////////////////////////////////////////////////////////////////////

        /**

         * This method is to verify token password

         *

         * @param userAlias

         * @param inPassword

         * @return ERR_code defined in the Constants<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND<br/>

         *         ERR_INVALID_STATE<br/>

         *         ERR_EXCEED_MAX_TRIES<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         *         ERR_PASSWD_EXPIRED<br/>

         *         ERR_REUSED_PASSWD<br/>

         */

        public int VerifyToken(String userAlias, String inPassword) {

                int rc = verifyToken(userAlias, inPassword);

                logger.info(userAlias + " Return=" + rc);

                return rc;

        }

        private int verifyToken(String userAlias, String inPassword) {

                DBOperations dbo = new DBOperations();

                TokenBean tb = new TokenBean();

                int rc = Constants.ERR_SYSTEM_NOT_READY;

                try {

                        tb = dbo.getTokenFromStoreByUserAlias(userAlias);

                        if (tb == null) {

                                dbo.close();

                                return Constants.ERR_USERALIAS_NOT_FOUND;

                        }

                        if (tb.getVstate() != Constants.TKN_STATE_ASSIGNED) {

                                dbo.close();

                                return Constants.ERR_INVALID_STATE;

                        }

                        TokenController tc = UPassFactory.getTokenController(tb);

                        rc = tc.verifyToken(inPassword, "", "");

                        tb = tc.getUpdatedObject();

                        // update first time used

                        if (tb.getVdateFirstUsed() == null) {

                                tb.setVdateFirstUsed(new Date());

                        }

                        // update last time used

                        tb.setVdateLastUsed(new Date());

                        // update database

                        boolean lrc = dbo.updateTokenToStore(tb);

                        dbo.close();

                        if (!lrc) {

                                return Constants.ERR_UNKNOWN;

                        }

                } catch (Exception e)

                {

                        e.printStackTrace();

                }

                return rc;

        }

        /**

         * This method is to reset user token <br/>

         *

         * @param adminUserAlias

         * @param adminUserPassword

         * @param userAlias

         * @return ERR_code defined in the Constants<br/>

         *         ERR_SUCCESS<br/>

         *         ERR_SYSTEM_NOT_READY<br/>

         *         ERR_USERALIAS_NOT_FOUND<br/>

         *         ERR_INVALID_STATE<br/>

         *         ERR_EXCEED_MAX_TRIES<br/>

         *         ERR_INVALID_CREDENTIAL<br/>

         */

        public int ResetToken(String adminUserAlias, String adminUserPassword, String userAlias) {

                int rc = resetToken(adminUserAlias, adminUserPassword, userAlias);

                logger.info(adminUserAlias + " " + userAlias + " Return=" + rc);

                return rc;

        }

        private int resetToken(String adminUserAlias, String adminUserPassword, String userAlias) {

                // verify supervisor password

                int rc = verifyStaticPassword(adminUserAlias, adminUserPassword, true, Constants.UTYPE_STATE_ADMIN);

                if (rc != Constants.ERR_SUCCESS) {

                        return rc;

                }

                DBOperations dbo = new DBOperations();

                TokenBean tb = new TokenBean();

                tb = dbo.getTokenFromStoreByUserAlias(userAlias);

                if (tb == null) {

                        dbo.close();

                        return Constants.ERR_USERALIAS_NOT_FOUND;

                }

                TokenController tc = UPassFactory.getTokenController(tb);

                rc = tc.resetToken();

                tb = tc.getUpdatedObject();

                // update database

                boolean lrc = dbo.updateTokenToStore(tb);

                dbo.close();

                if (!lrc) {

                        return Constants.ERR_UNKNOWN;

                }

                return rc;

        }

        /**

         * This method is to query token information, Return type is HashMap<String,String>

         * RC - Return Code [always present]<br/>

         * RT - Return Code in Text [always present]<br/>

         * <br/>

         * The following data present only with the return is ERR_SUCCESS<br/>

         * SerailNo - The serial number of token<br/>

         * State - Token State, [0-UNASSIGNED], [1-ASSIGNED], [2-DISABLE], [3-LOCKED], [4-DELETED]<br/>

         * UseCount - number of time of password authentication <br/>

         * ErrorCount - number of time error encountered of password authentication<br/>

         * DateAssigned - date of assignment to user<br/>

         * DateFirstUsed - date of 1st time use<br/>

         * DateLastUsed - date of last time used<br/>