LoginViewBean.java revision 7a7c465325b9715934a8a065f82f9692f99319f5
/**
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 2005 Sun Microsystems Inc. All Rights Reserved
*
* The contents of this file are subject to the terms
* of the Common Development and Distribution License
* (the License). You may not use this file except in
* compliance with the License.
*
* You can obtain a copy of the License at
* See the License for the specific language governing
* permission and limitations under the License.
*
* When distributing Covered Code, include this CDDL
* Header Notice in each file and include the License file
* at opensso/legal/CDDLv1.0.txt.
* If applicable, add the following below the CDDL Header,
* with the fields enclosed by brackets [] replaced by
* your own identifying information:
* "Portions Copyrighted [year] [name of copyright owner]"
*
* $Id: LoginViewBean.java,v 1.37 2009/11/11 12:22:32 bhavnab Exp $
*
*/
/*
* Portions Copyrighted 2010-2014 ForgeRock AS
*/
/**
* A default implementation of <code>LoginViewBean</code> auth Login UI.
*/
public class LoginViewBean
/**
* Creates <code>LoginViewBean</code> object.
*/
public LoginViewBean() {
super(PAGE_NAME);
}
/**
* register child view
*/
protected void registerChildren() {
super.registerChildren();
}
/**
*
*/
}
return new CallBackTiledView(this, TILED_CALLBACKS);
return new ButtonTiledView(this, TILED_BUTTONS);
} else {
return super.createChild(name);
}
}
/**
* Forwards the request to this view bean, displaying the page. This
* method is the equivalent of <code>RequestDispatcher.forward()</code>,
* meaning that the same semantics apply to the use of this method.
* This method makes implicit use of the display URL returned
* by the <code>getDisplayURL()</code> method.
* @param requestContext servlet context for auth request
*/
if (requestContext != null) {
}
if (AuthClientUtils.isVersionHeaderEnabled()) {
}
// get request ( GET ) parameters for 'login' process
}
if (loginDebug.messageEnabled()) {
//loginDebug.message("request data hash : " + reqDataHash);
}
isPost = true;
}
try {
boolean newOrgExist = false;
boolean isBackPost = false;
// if the request is a GET then iPlanetAMDirectoryPro cookie
// will be used to retrieve the session for session upgrade
//Check for session Timeout
clearCookie();
super.forwardTo(requestContext);
return;
}
}
//Commented out due to OPENAM-1215
//session.setAttribute("LoginURL", loginURL);
if (loginDebug.messageEnabled()) {
}
clearCookie();
} else {
if (!newOrgExist && !dontLogIntoDiffOrg) {
if (isPost) {
}
}
}
}
if (sessionUpgrade) {
if (loginDebug.messageEnabled()) {
"existing valid SSOToken");
}
newRequest = true;
|| authCookieValue.isEmpty()))
|| !isOrgSame()
if (loginDebug.messageEnabled()) {
+ orgName);
}
newRequest = true;
}
if (newRequest) {
if (cookieSupported) {
}
}
} else if ( (authCookieValue != null) &&
loginURL = getLoginURL();
cookieSupported = true;
} else {
cookieSupported = false;
}
}
}
if (loginDebug.messageEnabled()) {
}
}
processLogin();
if ((newRequest) &&
setCookie();
}
setlbCookie();
}
}
} catch (Exception e) {
setErrorMessage(e);
if (requestContext==null) {
return;
}
super.forwardTo(requestContext);
return;
}
// Set header for Misrouted server's usage
if (cookieSupported) {
setCookie();
}
try {
}
} catch (Exception e) {
if (loginDebug.messageEnabled()) {
"destroyToken error : " + e.toString());
}
}
if (loginDebug.messageEnabled()) {
}
}
}
// forward check for liberty federation, if the redirect_url
// is the federation post login servlet, use forward instead
try {
if (loginDebug.messageEnabled()) {
}
clearGlobals();
forward = false;
return;
} catch (Exception e) { // Servlet redirect error.
}
}
}
if (forward) {
forward = false;
super.forwardTo(requestContext);
}
clearGlobals();
}
/**
* Returns display url for auth auth Login UI
*
* @return display url for auth auth Login UI
*/
public String getDisplayURL() {
// redirect url gets a higher priority
// if URLRedirection class is implemented
// and customers want to use login failed url
jsp_page = "Redirect.jsp";
} else if ((errorTemplate != null) && (errorTemplate.length() != 0) && (!errorTemplate.equals("null"))) {
} else if ((ErrorMessage != null) && (ErrorMessage.length() != 0) && (!ErrorMessage.equals("null"))) {
jsp_page = "Message.jsp";
} else if ((pageTemplate != null) && (pageTemplate.length() != 0) && (!pageTemplate.equals("null"))) {
if (loginDebug.messageEnabled()) {
}
} else {
jsp_page = "Login.jsp";
}
if(timeout_jsp_page != null) {
} else {
}
} else {
}
}
}
/**
* Called as notification that the JSP has begun its display
* processing. In addition to performing the default behavior in the
* superclass's version, this method executes any auto-retrieving or auto-
* executing models associated with this view unless auto-retrieval is
* disabled.
*
* @param event Display Event.
* @throws ModelControlException if manipulation of a model fails during
* display preparation or execution of auto-retrieving models.
*/
throws ModelControlException {
if (newOrg) {
}
} else {
}
} else {
/*
setDisplayFieldValue(TXT_GOTO_LOGIN_AFTER_FAIL,
"Try again. Go To Login");
*/
}
}
//Set Redirect URL for MAP usage
}
private void processLogin() {
try {
bValidSession = true;
/*
* redirect to 'goto' parameter or SPI hook or default
* redirect URL.
*/
}
if (redirect_url == null) {
}
return;
}
if (loginDebug.messageEnabled()) {
}
return;
}
if (isPost) {
try {
if (loginDebug.messageEnabled()) {
}
}
} else {
try {
if (loginDebug.messageEnabled()) {
}
}
}
}
/**
* Handles button login request
* @param event request invocation event
*/
forwardTo();
}
/**
* Handles href login request
* @param event request invocation event.
*/
forwardTo();
}
private void parseUserCredentials() {
while (keys.hasMoreElements()) {
if(credentials == null) {
}
try {
} catch (NumberFormatException nfe) {
if (loginDebug.messageEnabled()) {
}
}
}
}
if (credentials == null) {
while (keys.hasMoreElements()) {
if(credentials == null) {
}
try {
} catch (NumberFormatException nfe) {
if (loginDebug.messageEnabled()) {
nfe.getMessage());
}
}
}
}
}
if (credentials != null) {
}
}
private void setOnePageLogin() {
// Auth Level login will never do one page login.
if (credentials != null) {
onePageLogin = true;
}
}
}
}
protected void getLoginDisplay() throws Exception {
if (!bAuthLevel) {
}
if (loginDebug.messageEnabled()) {
" IndexName = " + indexName);
}
try {
} else {
}
} else {
}
} catch (AuthLoginException le) {
LoginFail = true;
// redirect to 'gotoOnFail' parameter or SPI hook
// or default redirect URL.
}
return;
}
try {
// Get the information requested by the respective auth module
if (ac.hasMoreRequirements(true)) {
//AuthClientUtils.setCallbacksPerState(ac, pageState, callbacks);
} else {
if (loginDebug.messageEnabled()) {
"No more Requirements in getLoginDisplay");
}
LoginSuccess = true;
/*
* redirect to 'goto' parameter or SPI hook or default
* redirect URL.
*/
) {
}
if (loginDebug.messageEnabled()) {
"LoginSuccessURL in getLoginDisplay " +
"(in case of successful auth) : " + redirect_url);
}
LoginFail = true;
/*
* redirect to 'goto' parameter or SPI hook or default
* redirect URL.
*/
if ((gotoOnFailUrl == null) ||
}
if (loginDebug.messageEnabled()) {
"LoginFailedURL in getLoginDisplay : "
+ redirect_url);
}
LoginFail = true;
// AuthContext has been reset, send the client back to
// the login URL
redirect_url = getLoginURL();
} else {
}
if (loginDebug.messageEnabled()) {
"LoginFailedURL in getLoginDisplay : "
+ redirect_url);
}
} else {
if ((gotoOnFailUrl == null) ||
}
if (loginDebug.messageEnabled()) {
"LoginFailedURL in getLoginDisplay : "
+ redirect_url);
}
}
}
if (loginDebug.messageEnabled()) {
}
} catch(Exception e){
setErrorMessage(e);
new Object[]{e.getMessage()});
}
}
protected void processLoginDisplay() throws Exception {
try {
if (!onePageLogin){
return;
}
}
/*
String page_state = request.getParameter("page_state");
if (loginDebug.messageEnabled()) {
loginDebug.message("Submit with Page State : " + page_state);
}
if ((page_state != null) && (page_state.length() != 0)) {
callbacks = AuthClientUtils.getCallbacksPerState(ac, page_state);
//Get Callbacks in order to set the page state
Callback[] callbacksForPageState = AuthClientUtils.getRecdCallback(ac);
for (int i = 0; i < callbacksForPageState.length; i++) {
if (loginDebug.messageEnabled()) {
loginDebug.message(
"In processLoginDisplay() callbacksForPageState : "
+ callbacksForPageState[i]);
}
if (callbacksForPageState[i] instanceof
PagePropertiesCallback
) {
PagePropertiesCallback ppc =
(PagePropertiesCallback) callbacksForPageState[i];
if (loginDebug.messageEnabled()) {
loginDebug.message(
"setPageState in PPC to : " + page_state);
}
ppc.setPageState(page_state);
break;
}
}
} else {
callbacks = AuthClientUtils.getRecdCallback(ac);
}*/
// Assign user specified values
if (loginDebug.messageEnabled()) {
+ callbacks[i]);
}
if (callbacks[i] instanceof NameCallback) {
}
tmp = "";
}
} else if (callbacks[i] instanceof PasswordCallback) {
}
tmp = "";
}
} else if (callbacks[i] instanceof ChoiceCallback) {
}
choice = "0";
}
if (loginDebug.messageEnabled()) {
}
int selected = 0;
int[] selectIndexs = new int[cnt];
int j = 0;
if (loginDebug.messageEnabled()) {
}
while (st.hasMoreTokens()) {
selectIndexs[j] = selected;
j++;
if (loginDebug.messageEnabled()) {
+ choice + " & selected index : "
+ selected);
}
}
}
if (loginDebug.messageEnabled()) {
+ selectIndexs);
}
} else {
if (loginDebug.messageEnabled()) {
+ " & selected ONE index : " + selected);
}
}
} else if (callbacks[i] instanceof ConfirmationCallback) {
}
tmp = "";
}
int selectedIndex = 0;
selectedIndex = j;
}
}
if (loginDebug.messageEnabled()) {
+ " & selected button index : " + selectedIndex);
}
} else if (callbacks[i] instanceof PagePropertiesCallback) {
= (PagePropertiesCallback) callbacks[i];
} else if (callbacks[i] instanceof X509CertificateCallback) {
("javax.servlet.request.X509Certificate");
if (loginDebug.messageEnabled()) {
try {
"X509CertificateCallback - " +
"User Certificate : "
} catch (CertificateEncodingException e) {
"X509CertificateCallback - " +
e.toString());
}
}
}
} else if (callbacks[i] instanceof RedirectCallback) {
} else if (callbacks[i] instanceof HttpCallback) {
}
}
// testing
if (loginDebug.messageEnabled()) {
+ " Index name : " + indexName);
}
//testing
if (loginDebug.messageEnabled()) {
" is Auth Level or Composite Advice and selected "
+ "module is : " + choice);
}
indexName="LDAP";
} else {
}
bAuthLevel = true;
onePageLogin = true;
}
}
} else {
// Submit the information to auth module
// Check if more information is required
if (loginDebug.messageEnabled()) {
}
if (ac.hasMoreRequirements(true)) {
//AuthClientUtils.setCallbacksPerState(ac, pageState, callbacks);
} else {
if (loginDebug.messageEnabled()) {
}
LoginSuccess = true;
// redirect to 'goto' parameter or SPI hook or default
// redirect URL.
String successURLFromSession = ac.getSSOToken().getProperty(ISAuthConstants.POST_PROCESS_SUCCESS_URL);
if (successURLFromSession != null) {
}
}
if (loginDebug.messageEnabled()) {
" successful auth) : " + redirect_url);
}
LoginFail = true;
// redirect to 'goto' parameter or SPI hook or
// default redirect URL.
if ((gotoOnFailUrl == null) ||
}
if (loginDebug.messageEnabled()) {
+ redirect_url);
}
} else {
if ((gotoOnFailUrl == null) ||
}
if (loginDebug.messageEnabled()) {
"LoginFailedURL in getLoginDisplay : "
+ redirect_url);
}
}
}
}
if (loginDebug.messageEnabled()) {
loginDebug.message("processLoginDisplay::processRequestResponse=" + remoteRequestResponseProcessed);
}
} catch (Exception e) {
if (loginDebug.messageEnabled()) {
}
setErrorMessage(e);
new Object[]{e.getMessage()});
}
}
// Method to generate HTML page from Callback objects
throws Exception {
if (loginDebug.messageEnabled()) {
+ callbacks[i]);
}
if (callbacks[i] instanceof ConfirmationCallback) {
} else if (callbacks[i] instanceof PagePropertiesCallback) {
int lsize = 0;
}
if (loginDebug.messageEnabled()) {
+ "Info Text : " + infoText
+ " Page State : " + pageState);
}
onePageLogin = true;
break;
}
} else if (callbacks[i] instanceof X509CertificateCallback) {
onePageLogin = true;
break;
} else if (callbacks[i] instanceof RedirectCallback) {
if (loginDebug.messageEnabled()) {
loginDebug.message("addLoginCallbackMessage::processRequestResponse=" + remoteRequestResponseProcessed);
}
} else if (callbacks[i] instanceof HttpCallback) {
if (loginDebug.messageEnabled()) {
loginDebug.message("addLoginCallbackMessage::processRequestResponse=" + remoteRequestResponseProcessed);
}
}
}
return;
}
/**
* Processes the request and response objects, primarily the response
* object into the local HttpServletResponse
*
* @param req The incoming remote request
* @param res The incoming remote response
*/
return;
}
if (remoteRequest != null) {
// TODO should really worry the attributes
}
if (remoteResponse != null) {
if (loginDebug.messageEnabled()) {
}
if (loginDebug.messageEnabled()) {
}
}
}
}
}
// process only once per request
remoteRequestResponseProcessed = true;
}
}
/**
* Returns tile Index.
*
* @return Tile Index;
*/
public String getTileIndex() {
return str;
}
// Method to prepare 'login' method parameters from request object data
protected void prepareLoginParams() {
} else if (reqDataHash.get("service") != null && reqDataHash.get(Constants.COMPOSITE_ADVICE) == null) {
} else {
}
// Application auth is always 0 page login
onePageLogin = true;
}
}
}
}
// Process 'HttpCallback' initiated by Authentication module
if (hc.isForHTTPBasic()) {
} else if (hc.isForWindowsDesktopSSO()) {
}
}
if (loginDebug.messageEnabled()){
}
onePageLogin = true;
}
} else {
if (loginDebug.messageEnabled()){
}
forward = false;
return;
}
}
// Process 'RedirectCallback' initiated by Authentication module
forward = false;
}
// Method to check if this is Session Upgrade
checkNewOrg = false;
dontLogIntoDiffOrg = false;
try {
// always make sure the orgName is the same
if (loginDebug.messageEnabled()) {
}
//if new Org is not valid / does not exist
return checkNewOrg;
}
// if new Org is different from the old Org
}
if (loginDebug.messageEnabled()) {
}
if (loginDebug.messageEnabled()) {
"Destroy session.");
}
clearCookie();
if (loginDebug.messageEnabled()) {
"Don't destroy session.");
}
dontLogIntoDiffOrg = true;
return checkNewOrg;
}
} else {
newOrg = true;
errorTemplate = "new_org.jsp";
}
checkNewOrg = true;
}
} catch (Exception e) {
}
if (loginDebug.messageEnabled()) {
}
return checkNewOrg;
}
// Method to set DSAME cookie
private void setCookie() {
// No cookie domain specified in profile
if (cookieDomainSet.isEmpty()) {
try {
if (cookieTimeToLiveEnabled) {
if (loginDebug.messageEnabled()) {
+ "set cookie maxAge=" + cookieTimeToLive);
}
}
}
} catch (Exception e) {
}
} else {
if (loginDebug.messageEnabled()) {
if (cookieTimeToLive > 0) {
+ "would set cookie maxAge=" + cookieTimeToLive);
}
}
}
if (cookieTimeToLive > 0) {
}
}
if (loginDebug.messageEnabled()) {
}
}
}
}
}
// Method to set DSAME cookie
private void setServerCookies() {
try {
response);
}
}
}
}
}
}
/** Method to clear AM Cookie
*/
private void clearCookie() {
if (cookieSupported) {
response);
}
}
}
}
/** Method to clear cookie based on the cookie
* name passed (Auth or AM Cookie)
* @param cookieName name of cookie to be cleared.
*/
// No cookie domain specified in profile
if (cookieDomainSet.isEmpty()) {
try {
} catch (Exception e) {
}
} else {
}
}
}
private void setlbCookie(){
try {
} catch (Exception e) {
}
}
// get error template, message as well as error code.
private void setErrorMessage(Exception e) {
if ((e != null) && (e instanceof L10NMessage)) {
// in case this AuthLoginException is only a wrapper of
// LoginException which does not have errorCode.
if (authErrorCode != null) {
}
}
if (authErrorCode == null) {
// if error code can not be got from exception,
// then get error code and message from auth context
}
}
//if error code is still null, let's set it to AUTH_ERROR, so the
//template lookup will succeed
}
// if error message is still null,
// then get error message by using error code
}
} else {
}
if (loginDebug.messageEnabled()) {
}
}
// Method to retrieve filename
} else {
}
if (loginDebug.messageEnabled()) {
}
return relativeFileName;
}
// Get all the Original Auth credentials to start a new request
boolean gotOrigCredentials = false;
try {
if (tmpLoginURL != null) {
}
gotOrigCredentials = true;
} catch (Exception e){
}
if (loginDebug.messageEnabled()) {
+ loginURL);
+ orgName);
+ indexType);
+ indexName);
}
return gotOrigCredentials;
}
/**
* Clears all global variables.
*/
private void clearGlobals() {
}
/**
* Clear cookie and destroy session
*/
private void clearCookieAndDestroySession() {
// clear cookie, destroy orignal invalid session
if (cookieSupported) {
}
}
// Checks whether the subsequent request invokation is for the same Org as
// the previous request
private boolean isOrgSame() {
if (checkNewOrg && isPost) {
return false;
} else {
return true;
}
}
// Checks whether the subsequent request invokation is for the same Org as
// the previous request
private boolean isOrgChanged() {
// this method will only be used when AuthCookie is not null
}
return true;
} else {
return false;
}
}
// Returns the new LoginURL from the new request or
// from existing HttpSession
private String getLoginURL() {
}
}
}
return tmpLoginURL;
}
////////////////////////////////////////////////////////////////////////////
// Display cycle events:
// If the fireDisplayEvents attribute in a display field tag is set to true,
// then the begin/endDisplay events will fire for that display field.
////////////////////////////////////////////////////////////////////////////
/**
* Returns if it begins static text result display
* @param event child display event
* @return <code>true</code> by default.
*/
return true;
}
/**
* Returns if it begins content static text result display
* @param event child display event
* @return <code>false</code> if result value if null or empty.
*/
return false;
}
else {
return true;
}
}
/**
* Returns if it begins content static warning display
* @param event child display event
* @return <code>true</code> if lock warning is not null or not empty.
*/
if (loginDebug.messageEnabled()) {
}
}
/**
* Returns if it begins static text message display
* @param event child display event
* @return <code>true</code> by default.
*/
return true;
}
/**
* Returns if it begins content static text message display
* @param event child display event
* @return <code>true</code> if error message is not null or not empty.
*/
public boolean beginContentStaticTextMessageDisplay(
) {
}
/**
* Returns if it begins static text header display
* @param event child display event
* @return <code>true</code> by default.
*/
return true;
}
/**
* Returns if it begins content static text header display
* @param event child display event
* @return <code>true</code> if text header is not null or not empty.
*/
}
/**
* Returns if it begins href display
* @param event child display event
* @return <code>true</code> by default.
*/
return true;
}
/**
* Returns if it begins content href display
* @param event child display event
* @return <code>true</code> if result value is not null and account is not
* locked or error template is not null and not empty.
*/
&& LoginFail && !accountLocked)
}
/**
* Returns if it begins content button login display
* @param event child display event
* @return <code>true</code> if login is not completed.
*/
return (!LoginSuccess && !LoginFail);
}
/**
* Returns if it begins content image display
* @param event child display event
* @return <code>true</code> if page image is not null or not empty.
*/
}
/**
* gets display of valid content block
*
* @param event - child display event
* @return true of bean is valid
*/
}
/**
* begins display of has button content
*
* @param event - child display event
* @return true if there is one or more buttons
*/
}
/**
* begins display of has no button content
*
* @param event - child display event
* @return true if there is no button
*/
}
/**
* begins display of occupy full browser
*
* @param event - child display event
* @return false if session is in progress
*/
if (loginDebug.messageEnabled()) {
}
if (sessionUpgrade)
return false;
return true;
}
public void enableCookieTimeToLive() {
if ((cookieTimeToLiveString != null)
try {
if (loginDebug.messageEnabled()) {
+ "cookieTimeToLive=" + cookieTimeToLive);
}
} catch (NumberFormatException nfe) {
if (loginDebug.warningEnabled()) {
+ "not a valid number, leaving cookieTimeToLive as 0");
}
}
}
if (cookieTimeToLive > 0) {
cookieTimeToLiveEnabled = true;
if (loginDebug.messageEnabled()) {
}
new Integer(cookieTimeToLive));
} else {
if (loginDebug.messageEnabled()) {
+ "cookieTimeToLive not enabled");
}
}
}
public int getCookieTimeToLive() {
"distAuth.cookieTimeToLive"))).intValue()
: 0;
}
public boolean isCookieTimeToLiveEnabled() {
"distAuth.cookieTimeToLiveEnabled"))).booleanValue()
: false;
}
////////////////////////////////////////////////////////////////////////////
// Class variables
////////////////////////////////////////////////////////////////////////////
boolean checkNewOrg = false;
boolean dontLogIntoDiffOrg = false;
/** Page name for login */
/** Page name for session time out */
/** Result value */
/** Error message */
/** Error template */
/** Error code */
/** Lock warning */
/** Account lock */
public boolean accountLocked=false;
/** Text header value */
/** Redirect url */
/** Page state */
/** Choice */
/** Page template */
/** Page image */
/** Login failure */
public boolean LoginFail = false;
/** Login success */
public boolean LoginSuccess = false;
/** Auth level */
public boolean bAuthLevel = false;
/** Session is valid */
public boolean bValidSession = false;
/** Request is post */
public boolean isPost = false;
/** Required list */
private boolean cookieSupported = true;
boolean newRequest = false;
private boolean onePageLogin = false;
private boolean sessionUpgrade = false;
private boolean forward = true;
private boolean newOrg = false;
private boolean bHttpBasic = false;
/** List of callback */
/** List of button options */
/** Default button index */
public int defaultButtonIndex = 0;
/** Goto url */
/** Goto url for login failure */
private boolean cookieTimeToLiveEnabled = false;
private int cookieTimeToLive = 0;
private boolean remoteRequestResponseProcessed = false;
/** Default parameter name for old token */
/** Default parameter name for token */
/** Default parameter name for old button */
/** Default parameter name for id button */
/** Default parameter name for page state */
/** Default parameter name for login url */
/** Default parameter name for default login url */
/** Default parameter name for redirect url */
/** Default parameter name for tiled callback */
/** Default parameter name for tiled buttons */
/** Default parameter name for default buttons */
/** Default parameter name for text goto login after failure */
public static final String TXT_GOTO_LOGIN_AFTER_FAIL =
"txtGotoLoginAfterFail";
/** Default parameter name for submit command */
/** Default parameter name for submit label */
/** Default parameter name for continue command */
/** Default parameter name for continue label */
/** Default parameter name for agree command */
/** Default parameter name for agree label */
/** Default parameter name for disagree command */
/** Default parameter name for disagree label */
/** Default parameter name for command yes */
/** Default parameter name for label yes */
/** Default parameter name for command no */
/** Default parameter name for label no */
/** Default parameter name for command new user */
/** Default parameter name for label new user */
/** Default parameter name for label reset */
/** Default parameter name for login html title */
/** Default parameter name for login title message */
/** Default parameter name for redirect html title */
/** Default parameter name of html title for account expired */
public static final String HTML_TITLE_ACCOUNTEXPIRED
= "htmlTitle_AccountExpired";
/** Default parameter name of html title for auth error */
/** Default parameter name of html title for self registration error */
public static final String HTML_TITLE_SELFREGERROR
= "htmlTitle_SelfRegError";
/** Default parameter name of html title for disclaimer */
/** Default parameter name of html title for invalid cookie id */
public static final String HTML_TITLE_INVALIDPCOOKIEUID
= "htmlTitle_InvalidPCookieUID";
/** Default parameter name of html title for invalid password */
public static final String HTML_TITLE_INVALIDPASSWORD
= "htmlTitle_InvalidPassword";
/** Default parameter name of html title for invalid domain */
public static final String HTML_TITLE_INVALIDDOMAIN
= "htmlTitle_InvalidDomain";
/** Default parameter name of html title for user profile not found */
public static final String HTML_TITLE_USERPROFILENOTFOUND
= "htmlTitle_UserProfileNotFound";
/** Default parameter name of html title for auth failure */
/** Default parameter name of html title for membership */
/** Default parameter name of html title for auth module denied */
public static final String HTML_TITLE_AUTHMODULEDENIED
= "htmlTitle_AuthModuleDenied";
/** Default parameter name of html title for no config error */
public static final String HTML_TITLE_NOCONFIGERROR
= "htmlTitle_NoConfigError";
/** Default parameter name of html title for org inactive */
/** Default parameter name of html title for self module registration */
public static final String HTML_TITLE_SELFREGMODULE
= "htmlTitle_SelfRegModule";
/** Default parameter name of html title for session timeout */
public static final String HTML_TITLE_SESSIONTIMEOUT
= "htmlTitle_SessionTimeOut";
/** Default parameter name of html title for user not found */
public static final String HTML_TITLE_USERNOTFOUND
= "htmlTitle_UserNotFound";
/** Default parameter name of html title for user inactive */
public static final String HTML_TITLE_USERINACTIVE
= "htmlTitle_UserInactive";
/** Default parameter name of html title for new organization */
/** Default parameter name of html title for max session */
////////////////////////////////////////////////////////////////////////////
// Instance variables
////////////////////////////////////////////////////////////////////////////
static {
}
}