skinutils.java

java开发的一套非常好用的oa系统

/**
 * $RCSfile: SkinUtils.java,v $
 * $Revision: 1.1.1.1 $
 * $Date: 2002/09/09 13:51:08 $
 *
 * New Jive  from Jdon.com.
 *
 * This software is the proprietary information of CoolServlets, Inc.
 * Use is subject to license terms.
 */

package com.jivesoftware.forum.util;

import java.io.*;
import java.text.*;
import java.util.*;

import javax.servlet.*;
import javax.servlet.http.*;

import com.jivesoftware.forum.*;
import com.jivesoftware.util.*;


/**
 * A collection of utility methods for use in Jive Skins. Because these
 * methods make skin development much easier, skin authors should study them
 * carefully.<p>
 *
 * Three major areas of funtionality are provided:<p><ol>
 *  <li> Methods that simplify Authorization tasks:
 *    <ul>
 *      <li>{@link #login(HttpServletRequest, HttpServletResponse, String, String, boolean)}
 *      <li>{@link #getUserAuthorization(HttpServletRequest, HttpServletResponse)}
 *      <li>{@link #removeUserAuthorization(HttpServletRequest, HttpServletResponse)}
 *    </ul>
 *    <p>
 *  <li> Methods that get and set Session and cookie values.
 *    <ul>
 *      <li>{@link #getCookie(HttpServletRequest, String)}
 *      <li>{@link #remove(HttpServletRequest, HttpServletResponse, String)}
 *      <li>{@link #retrieve(HttpServletRequest, HttpServletResponse, String)}
 *      <li>{@link #store(HttpServletRequest, HttpServletResponse, String, String)}
 *      <li>{@link #store(HttpServletRequest, HttpServletResponse, String, String, int)}
 *      <li>{@link #store(HttpServletRequest, HttpServletResponse, String, String, int boolean)}
 *    </ul>
 *    <p>
 *  <li> Date methods.
 *    <ul>
 *      <li>{@link #dateToText(HttpServletRequest, HttpServletResponse, User, Date)}
 *      <li>{@link #formatDate(HttpServletRequest, HttpServletResponse, User, Date)}
 *      <li>{@link #getLastVisited(HttpServletRequest, HttpServletResponse)}
 *    </ul>
 *  <li> Other methods.
 *    <ul>
 *      <li>{@link #quoteOriginal(String, String, int)}
 *      <li>{@link #getResourceBundle(String, Locale)}
 *    </ul>
 * </ol>
 *
 */
public class SkinUtils {

  /** Name of the authentication token (stored in the user's session) */
  private static final String JIVE_AUTH_TOKEN = "jive.authorization.token";

  /** Name of the cookie used to store user info for auto-login purposes */
  private static final String JIVE_AUTOLOGIN_COOKIE =
      "jive.authorization.autologin";

  /** Name of the last visited token (stored in the user's session) */
  private static final String JIVE_LASTVISITED_TOKEN = "jive.user.lastvisited";

  // Default cookie time to live (in seconds).
  private static final int MAX_COOKIE_AGE = (int) (JiveGlobals.WEEK / 1000) * 8;

  // Days of the week
  private static final String[] DAYS_OF_WEEK = {
      "Sun", "Mon", "Tues", "Wed", "Thurs", "Fri", "Sat"};
  // Months of the year
  private static final String[] MONTHS_OF_YEAR = {
      "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
      "Sep", "Oct", "Nov", "Dec"};

  // "Tweakable" parameters for the cookie password encoding. NOTE: changing
  // these and recompiling this class will essentially invalidate old cookies.
  private final static int ENCODE_XORMASK = 0x5A;
  private final static char ENCODE_DELIMETER = '\002';
  private final static char ENCODE_CHAR_OFFSET1 = 'A';
  private final static char ENCODE_CHAR_OFFSET2 = 'h';

  // A cache of DateFormat objects:
  private static HashMap dateFormatCache = new HashMap();

  // A reuseable global calendar object
  private static Calendar globalCal = Calendar.getInstance();

  private static String CODE = "CODE";

  public static String getPassword(int length) {
    String key =
        "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

    StringBuffer sb = new StringBuffer();

    for (int i = 0; i < length; i++) {
      sb.append(key.charAt( (int) (Math.random() * key.length())));
    }

    return sb.toString();
  }

  public static String getRegisterCode(HttpServletRequest request,
                                       HttpServletResponse response) {
    String registerCode = "1234";
    try {
      HttpSession session = request.getSession();
      registerCode = getPassword(4);
      session.setAttribute(CODE, registerCode);
    }
    catch (Exception ex) {
      System.err.println(" getRegisterCode error : " + registerCode + ": " + ex);
    }
    return registerCode;
  }

  public static boolean verifyRegisterCode(String registerCodeIn,
                                           HttpServletRequest request,
                                           HttpServletResponse response) {
    boolean isTrue = false;
    String registerCode = "1234";
    try {
      HttpSession session = request.getSession();
      registerCode = (String) session.getAttribute(CODE);
      if ( (registerCode != null) &&
          (registerCodeIn.equalsIgnoreCase(registerCode)))
        isTrue = true;
    }
    catch (Exception ex) {
      System.err.println(" verifyRegisterCode : " + ex);
    }

    return isTrue;
  }

  /**
   * Returns an Authorization token for the user. The session is first checked
   * and if the token is not found, the Jive cookie is checked. If the cookie
   * is found,
   *
   * @param request the HttpServletRequest object, known as "request" in a
   *      JSP page.
   * @param response The HttpServletResponse object, known as "response" in
   *      a JSP page.
   * @return A users's authorization token if they're already authenticated,
   *      otherwise <code>null</code>.
   */
  public static Authorization getUserAuthorization
      (HttpServletRequest request, HttpServletResponse response) {
    HttpSession session = request.getSession();

    // Check 1: check for the Jive authentication token in the user's session.
    Authorization authToken = (Authorization) session.getAttribute(
        JIVE_AUTH_TOKEN);
    if (authToken != null) {
      return authToken;
    }

    // Check 2: check the jive cookie for username and password
    Cookie cookie = getCookie(request, JIVE_AUTOLOGIN_COOKIE);
    if (cookie != null) {
      try {
        // at this point, we found a cookie so grab the username and
        // password from it, create an authorization token and store
        // that in the session
        String[] values = decodePasswordCookie(cookie.getValue());
        String username = values[0];
        String password = values[1];
        // Try to validate the user based on the info from the cookie.
        // Catch any exceptions
        authToken = AuthorizationFactory.getAuthorization(username, password);
      }
      catch (Exception e) {}

      // put that token in the user's session:
      if (authToken != null) {
        session.setAttribute(JIVE_AUTH_TOKEN, authToken);
      }

      // return the authorization token
      return authToken;
    }
    return null;
  }

  /**
   * Validates the user and optionally enables auto-login by creating an
   * auto-login cookie.
   *
   * @param request the HttpServletRequest object, known as "request" in a JSP page.
   * @param response the HttpServletResponse object, known as "response" in a JSP page.
   * @param username the username.
   * @param password the password.
       * @param autoLogin if <code>true</code> create a cookie that enables auto-login.
   * @throws UserNotFoundException
   * @throws UnauthorizedException
   */
  public static Authorization login(HttpServletRequest request,
                                    HttpServletResponse response,
                                    String username, String password,
                                    boolean autoLogin) throws
      UserNotFoundException, UnauthorizedException {
    HttpSession session = request.getSession();
    Authorization authToken = AuthorizationFactory.getAuthorization(username,
        password);
    session.setAttribute(JIVE_AUTH_TOKEN, authToken);

    // If auto-login is enabled, create the auto-login cookie
    if (autoLogin) {
      saveCookie(response, JIVE_AUTOLOGIN_COOKIE,
                 encodePasswordCookie(username, password));
    }
    return authToken;
  }

  public static Authorization setUserAuthorization(HttpServletRequest request,
      HttpServletResponse response, String username, String password,
      boolean autoLogin) throws UserNotFoundException, UnauthorizedException {
    return login(request, response, username, password, autoLogin);
  }

  /**
   *  Removes a user's token from the session and invalidates the auto-login
   *  cookie (if one exists).
   *
   *  @param request the HttpServletRequest object; "request" in JSP pages.
   *  @param response the HttpServletResponse object; "response" in JSP pages.
   */
  public static void logout(HttpServletRequest request,
                            HttpServletResponse response) {
    HttpSession session = request.getSession();
    session.removeAttribute(JIVE_AUTH_TOKEN);
    deleteCookie(request, response, JIVE_AUTOLOGIN_COOKIE);
  }

  public static void removeUserAuthorization(HttpServletRequest request,
                                             HttpServletResponse response) {
    logout(request, response);
  }

  /**
   * Invalidates the specified cookie.
   */
  public static void deleteCookie(HttpServletRequest request,
                                  HttpServletResponse response,
                                  String cookieName) {
    // invalidate the cookie
    Cookie cookie = new Cookie(cookieName, "");
    // delete the cookie when the user closes their webbrowser
    cookie.setMaxAge(0);
    cookie.setPath("/");
    response.addCookie(cookie);
  }

  /**
   *  Persists a value for the length of the user's session.
   *
   *  @see SkinUtils#store(HttpServletRequest,HttpServletResponse,String,String,int) store
   */
  public static void store(HttpServletRequest request,
                           HttpServletResponse response,
                           String id, String value) {
    // By default, we'll just store the value in the session (saveTime
    // is zero)
    store(request, response, id, value, 0);
  }

  /**
   *  This method should be used in a skin to store an arbritary value.
   *  For example, we could persist the name of a user so that on a form page
   *  where they enter their name, that field could be auto-filled in with
   *  the stored value.
   *  <p>
   *  To indicate that the data should only be persisted for a session, pass
   *  in 0 as the <code>timeToLive</code>. Otherwise, the value will be
   *  saved for one month.
   *
   *  @param request The HttpServletRequest object, known as "request" on a
   *      JSP page.
   *  @param response The HttpServletRequest object, known as "response" on a
   *      JSP page.
   *  @param id The name or identifier of the data you want to persist.
   *  @param value The value you wish to store.
   *  @param saveTime The length (in seconds) this value will persist. Any
   *      value of 0 or less indicates this data should only persist for
   *      a session.
   */
  public static void store(HttpServletRequest request,
                           HttpServletResponse response, String id,
                           String value, int saveTime) {
    // If the id is null, return
    if (id == null) {
      return;
    }

    // Get the session object
    HttpSession session = request.getSession();

    // Store the value in the session
    session.setAttribute(id, value);

    // if the timeToLive param is > 0, store to a cookie
    if (saveTime > 0) {
      saveCookie(response, id, value, saveTime);
    }