LoginViewBean.java revision b85923b109a33303f3aa66b43e56552bb1fb12c8
/*
* 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.28 2009/11/25 11:58:53 manish_rustagi Exp $
*
* Portions Copyrighted 2010-2016 ForgeRock AS.
* Portions Copyrighted 2012 Nomura Research Institute, Ltd
*/
/**
* This class is a default implementation of <code>LoginViewBean</code>
* auth Login UI.
*/
public class LoginViewBean extends AuthViewBeanBase {
/**
* 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);
return new StaticTextField(
this, HTML_TITLE_USERPROFILENOTFOUND, "");
} 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);
}*/
// Set header for Misrouted server's usage
if (loginDebug.messageEnabled()) {
}
isPost = true;
}
try {
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
super.forwardTo(requestContext);
return;
}
}
} else {
if (newOrg) {
}
if (!newOrgExist) {
if (isPost) {
}
if (forceAuth) {
sessionUpgrade = true;
} else {
}
if (loginDebug.messageEnabled()) {
"Session Upgrade = " + sessionUpgrade);
}
}
}
}
if (logIntoDiffOrg) {
//session is already deleted, so we should just continue our login process
newOrgExist = true;
} else {
}
}
try {
+ "authenticated");
bValidSession = true;
/*
* redirect to 'goto' parameter or SPI hook or default
* redirect URL.
*/
}
}
if (redirect_url == null) {
}
LoginSuccess = true;
if (loginDebug.messageEnabled()) {
+ redirect_url);
}
} else {
}
return;
}
if (loginDebug.messageEnabled()) {
}
}
}
}
// clear the cookie only if cookie supported
if (sessionUpgrade) {
try {
clearGlobals();
return;
} catch (Exception e) {
}
} else {
// clear AM Cookie if it exists.
}
// clear Auth Cookie if it exists.
}
}
}
if (loginDebug.messageEnabled()) {
}
if (sessionUpgrade) {
}
}
}
// check session or new request
// add cookie only if cookie is supported
if (!isBackPost) {
}
/*if (loginDebug.messageEnabled()) {
loginDebug.message("loginURL : " + loginURL);
}*/
// Check whether need to detect the cookie support in the browser
errorTemplate = "Message.jsp";
}
}
setCookie();
setlbCookie();
}
} else {
// check if client still have the cookie we set.
} else {
}
}
}
} catch (Exception e) {
if (loginDebug.messageEnabled()) {
}
setErrorMessage(e);
if (requestContext==null) {
return;
}
super.forwardTo(requestContext);
return;
}
processLogin();
clearGlobals();
return;
}
}
// forward check for liberty federation, if the redirect_url
// is the federation post login servlet, use forward instead
// Override the doForward if the redirect_url is an absolute URL, for example: http://test.example.com
// This can occur as a result of a failed login during a Federation login and the Failure Login URL has
// been set to an absolute URL
try {
doForward = false;
}
} catch (URISyntaxException e) {
}
try {
if (loginDebug.messageEnabled()) {
}
// destroy session if necessary.
"forwardTo(): Auth failed - Destroy Session!");
"forwardTo(): Session upgrade - " +
"Restoring original Session!");
if (oldSession != null) {
}
} else {
if (oldSession != null) {
}
}
"Login failure, current session destroyed!");
if (loginDebug.messageEnabled()) {
+ "Restoring updated session");
}
} else {
setCookie();
}
oldSession != null) {
}
}
}
clearGlobals();
if(loginDebug.messageEnabled()){
"Forward URL before appending cookie is " +
}
//since this is a request FORWARD, we MUST add the session id to the URL, otherwise federation
//would not have any knowledge about the freshly created session ID - this can be especially
//a problem, when upgrading session: old session ID cookie is still present in the request
//but the new isn't.
} else {
}
if (cookieValue != null) {
}
if(loginDebug.messageEnabled()){
}
} else {
}
forward = false;
return;
} catch (IOException e) {
e);
} catch (Exception e) {
loginDebug.error("LoginViewBean.forwardTo(): There was an Exception doing the forward/redirect", e);
setErrorMessage(e);
redirect_url = null;
}
}
}
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";
jsp_page = "Message.jsp";
if (loginDebug.messageEnabled()) {
}
} else {
jsp_page = "Login.jsp";
}
if (loginDebug.messageEnabled()) {
}
if (loginDebug.messageEnabled()) {
+ "Restoring updated session");
}
if (oldSession != null) {
}
} else {
setCookie();
}
try {
if (oldSession != null) {
if (loginDebug.messageEnabled()) {
"original session Successful!");
}
}
} catch (Exception e) {
if (loginDebug.messageEnabled()) {
"original session Failed! " + e.getMessage());
}
}
}
if (loginDebug.messageEnabled()) {
}
// clear cookie ,destroy failed session
"Session upgrade - Restoring original Session!");
if (oldSession != null) {
}
} else {
// clear cookie ,destroy failed session
if (oldSession != null) {
}
}
}
}
}
/**
* 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() {
if (isPost && !newOrgExist) {
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();
}
protected void getLoginDisplay() throws Exception {
if (!bAuthLevel) {
}
if (loginDebug.messageEnabled()) {
}
try {
} else {
}
} else {
}
} catch (AuthLoginException le) {
"getLoginDisplay(): Destroying current session!");
" Restoring original Session!");
if (oldSession != null) {
if (loginDebug.messageEnabled()) {
"Session Upgrade - redirect_url : "
+ redirect_url);
}
}
forward=false;
} else {
if (oldSession != null) {
}
}
} else {
}
return;
}
try {
// Get the information requested by the respective auth module
if (ac.hasMoreRequirements()) {
if (callbacks[i] instanceof HttpCallback) {
return;
} else if (callbacks[i] instanceof RedirectCallback) {
return;
} else if (!bAuthLevel && !newOrgExist) {
// Auth Level login will never do one page login.
if (callbacks[i] instanceof NameCallback) {
onePageLogin = true;
break;
onePageLogin = true;
break;
}
} else if (callbacks[i] instanceof PasswordCallback) {
onePageLogin = true;
break;
onePageLogin = true;
break;
}
} else if (callbacks[i] instanceof ChoiceCallback) {
onePageLogin = true;
break;
onePageLogin = true;
break;
}
} else if(callbacks[i] instanceof ConfirmationCallback){
onePageLogin = true;
break;
onePageLogin = true;
break;
}
}
}
}
if (onePageLogin &&
// user input login info in URL
} else {
if (!LoginFail) {
//if the login already failed, then LoginState is already
//nullified, hence any attempt of calling this method
//the errormessage/code/template should be already set
//so a proper error page is shown.
}
}
} 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 to 'goto' parameter or SPI hook or default
* redirect URL.
*/
if (loginDebug.messageEnabled()) {
"LoginFailedURL in getLoginDisplay : "
+ redirect_url);
}
}
} else {
/*
* redirect to 'goto' parameter or SPI hook or default
* redirect URL.
*/
if (loginDebug.warningEnabled()) {
" - redirect to loginFailedURL : " + redirect_url);
}
}
}
} catch(Exception e){
setErrorMessage(e);
new Object[]{e.getMessage()});
}
}
// Process 'HttpCallback' initiated by Authentication module
onePageLogin = true;
} else {
if (loginDebug.messageEnabled()){
}
forward = false;
return;
}
}
// Process 'RedirectCallback' initiated by Authentication module
onePageLogin = true;
} else {
forward = false;
}
}
protected void processLoginDisplay() throws Exception {
try {
if (!onePageLogin){
"In processLoginDisplay() : Session New ");
return;
}
}
if (loginDebug.messageEnabled()) {
}
return;
}
//Get Callbacks in order to set the page state
if (loginDebug.messageEnabled()) {
"In processLoginDisplay() callbacksForPageState : "
+ callbacksForPageState[i]);
}
if (callbacksForPageState[i] instanceof
) {
if (loginDebug.messageEnabled()) {
"setPageState in PPC to : " + page_state);
}
break;
}
}
} else {
}
if (loginDebug.messageEnabled()) {
}
return;
}
// 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) {
}
if (loginDebug.messageEnabled()) {
}
if (loginDebug.messageEnabled()) {
}
int[] selectIndexs = new int[cnt];
int j = 0;
if (loginDebug.messageEnabled()) {
}
while (st.hasMoreTokens()) {
selectIndexs[j++] = selected;
if (loginDebug.messageEnabled()) {
selected);
}
}
}
if (loginDebug.messageEnabled()) {
}
} else {
if (loginDebug.messageEnabled()) {
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 RedirectCallback) {
}
}
// testing
if (loginDebug.messageEnabled()) {
+ " Index name : " + indexName);
}
//testing
if (loginDebug.messageEnabled()) {
" is Auth Level or Composite Advice and selected Module " +
"or Service is : " + choice);
}
}
} else {
}
bAuthLevel = true;
onePageLogin = true;
}
}
if (loginDebug.messageEnabled()) {
}
} else {
// Submit the information to auth module
// Check if more information is required
if (loginDebug.messageEnabled()) {
}
if (ac.hasMoreRequirements()) {
if (callbacks[i] instanceof HttpCallback) {
return;
} else if (callbacks[i] instanceof RedirectCallback) {
(RedirectCallback)callbacks[i]);
return;
}
}
if (!LoginFail) {
//if the login already failed, then LoginState is already
//nullified, hence any attempt of calling this method
//the errormessage/code/template should be already set
//so a proper error page is shown.
}
} else {
if (loginDebug.messageEnabled()) {
"No more Requirements : Status is : "
}
LoginSuccess = true;
/*
* redirect to 'goto' parameter or SPI hook or default
* redirect URL.
*/
if ((redirect_url != null) &&
) {
if (loginDebug.messageEnabled()) {
"LoginSuccessURL (in case of " +
" successful auth) : " + redirect_url);
}
}
/*
* redirect to 'goto' parameter or SPI hook or default
* redirect URL.
*/
if ((redirect_url != null) &&
) {
if (loginDebug.messageEnabled()) {
+ redirect_url);
}
}
} else {
/*
* redirect to 'goto' parameter or SPI hook or default
* redirect URL.
*/
if (loginDebug.warningEnabled()) {
" - redirect to loginFailedURL : " +
}
}
}
}
} 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);
}
// empty callback processing
onePageLogin = true;
break;
}
}
}
}
/**
* Returns tile Index.
*
* @return Tile Index;
*/
public String getTileIndex() {
}
// Method to prepare 'login' method parameters from request object data
protected void prepareLoginParams() {
}
} else {
}
// Application auth is always 0 page login
onePageLogin = true;
}
}
}
}
// Method to check if this is Session Upgrade
boolean checkNewOrg = 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
newOrg = true;
errorTemplate = "new_org.jsp";
checkNewOrg = true;
}
} catch (Exception e) {
}
if (loginDebug.messageEnabled()) {
}
return checkNewOrg;
}
}
if (loginDebug.messageEnabled()) {
}
logIntoDiffOrg = true;
try {
} catch (SSOException ssoe) {
}
logIntoDiffOrg = false;
}
} else {
}
}
// Method to set DSAME cookie
private void setCookie() {
try {
int cookieTimeToLive = 0;
if (isCookieTimeToLiveEnabled()) {
if ((cookieTimeToLive > 0)
if (loginDebug.messageEnabled()) {
+ "set cookie maxAge=" + cookieTimeToLive);
}
}
}
}
} catch (Exception e) {
}
} else {
int cookieTimeToLive = 0;
if (isCookieTimeToLiveEnabled()) {
if (loginDebug.messageEnabled()) {
}
}
}
}
if (loginDebug.messageEnabled()) {
}
}
}
}
}
private void setlbCookie(){
try {
} catch (Exception e) {
}
}
/** Method to clear AM Cookie
*/
}
}
/**
* Method to clear cookie based on the cookie
* name passed (Auth or AM Cookie)
* @param cookieName name of cookie to be cleared.
*/
} else {
}
}
}
}
}
}
}
// get error template, message as well as error code.
private void setErrorMessage(Exception e) {
if ((e != null) && (e instanceof L10NMessage)) {
// if exception is instance of L10NMessage,
// then get error code from exception
// 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 {
}
// handle InternalSession timeout
}
if (loginDebug.messageEnabled()) {
}
}
// Method to retrieve filename
} else {
}
if (loginDebug.messageEnabled()) {
}
return relativeFileName;
}
/** Retrieves the original AuthContext and the session,
* sets the cookie and retrieves the original
* success login url.
* @return redirect_url, a String
*/
if (oldSession != null) {
}
return redirect_url;
}
// Get all the Original Auth credentials to start a new request
boolean gotOrigCredentials = false;
try {
gotOrigCredentials = true;
} catch (Exception e){
}
if (loginDebug.messageEnabled()) {
"canGetOrigCredentials : IndexType = " + indexType);
"canGetOrigCredentials : IndexName = " + indexName);
}
return gotOrigCredentials;
}
/**
* Clears all global variables.
*/
private void clearGlobals() {
}
/** Clear cookie and destroy session
* @param ac AuthContext for this request
*/
// clear cookie, destroy orignal invalid session
}
}
LoginFail = true;
}
////////////////////////////////////////////////////////////////////////////
// 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.
////////////////////////////////////////////////////////////////////////////
// StaticTextResult ( Result )
/**
* 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.
*/
}
/**
* 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;
}
/**
* Enables AM session cookie time to live
*/
public void enableCookieTimeToLive() {
int cookieTimeToLive = 0;
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) {
boolean cookieTimeToLiveEnabledFlag = true;
if (loginDebug.messageEnabled()) {
}
} else {
if (loginDebug.messageEnabled()) {
+ "cookieTimeToLive not enabled");
}
}
}
/**
* Checks whether AM session cookie time to live is enabled
* @return <code>true</code> if AM session cookie time to live
* is enabled, otherwise returns <code>false</code>
*/
public boolean isCookieTimeToLiveEnabled() {
}
/**
* Returns AM session cookie time to live
* @return AM session cookie time to live in seconds
*/
public int getCookieTimeToLive() {
}
/**
* Returns the name of the current realm
* @return Realm name for current context
*/
public String getRealmName() {
return null;
}
return ls.getOrgName();
}
return null;
}
/**
* Returns the service (authentication chain name)
* @return Applicable service for current context, or null if service based authentication is not being used.
*/
public String getAuthChainName() {
return null;
}
return ls.getIndexName();
}
return null;
}
////////////////////////////////////////////////////////////////////////////
// Class variables
////////////////////////////////////////////////////////////////////////////
/** Page name for login */
/** 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 onePageLogin = false;
private boolean sessionUpgrade = false;
private boolean forward = true;
private boolean newOrg = false;
private boolean bHttpBasic = false;
private boolean newOrgExist = false;
private boolean logIntoDiffOrg = false;
/** List of callback */
/** List of button options */
/** Default button index */
public int defaultButtonIndex = 0;
private boolean forceAuth;
/** 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 new user command */
/** Default parameter name for new user label */
/** Default parameter name for reset label */
/** 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 */
/** 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 */
public static final String HTML_TITLE_ORGINACTIVE =
"htmlTitle_OrgInactive";
/** 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 {
}
}