Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that implements administrative methods 

 *  Copyright: 2008 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Michael Daigle

 * 

 *   '$Author: leinfelder $'

 *     '$Date: 2011-02-04 06:17:53 -0800 (Fri, 04 Feb 2011) $'

 * '$Revision: 5914 $'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.util;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.IOException;

import java.io.BufferedReader;

import java.io.PrintWriter;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLConnection;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import java.util.Vector;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.http.Cookie;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import org.apache.commons.io.IOUtils;

import org.apache.http.HttpException;

import org.apache.http.HttpResponse;

import org.apache.http.HttpVersion;

import org.apache.http.NameValuePair;

import org.apache.http.client.HttpClient;

import org.apache.http.client.entity.UrlEncodedFormEntity;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.message.BasicNameValuePair;

import org.apache.http.params.CoreProtocolPNames;

import org.apache.log4j.Logger;

import edu.ucsb.nceas.metacat.properties.PropertyService;

import edu.ucsb.nceas.metacat.service.SessionService;

import edu.ucsb.nceas.metacat.shared.MetacatUtilException;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

public class RequestUtil {

	private static Logger logMetacat = Logger.getLogger(RequestUtil.class);

	private static String encoding = "UTF-8";

	/**

	 * private constructor - all methods are static so there is no

     * no need to instantiate.

	 */

	private RequestUtil() {}

	/**

	 * Forward a request that was received by this servlet on to another JSP

	 * page or servlet to continue handling the request.

	 * 

	 * @param request

	 *            to be forwarded

	 * @param response

	 *            that can be used for writing output to the client

	 * @param destination

	 *            the context-relative URL to which the request is forwarded

	 * @param params the request parameters.  these will be added to the request

	 */

	public static void forwardRequest(HttpServletRequest request, HttpServletResponse response, 

			String destinationUrl, Hashtable<String, String[]> params) throws MetacatUtilException {

		destinationUrl += "?" + paramsToQuery(params);

		logMetacat.debug("Forwarding request to " + destinationUrl);

		ServletContext servletContext = request.getSession()

				.getServletContext();

		try {

			servletContext.getRequestDispatcher(destinationUrl).forward(request, response);

		}  catch (IOException ioe) {

			throw new MetacatUtilException("RequestUtil.forwardRequest - I/O error when forwarding to " + 

					destinationUrl + " : " + ioe.getMessage());			

		} catch (ServletException se) {

			throw new MetacatUtilException("RequestUtil.forwardRequest - Servlet error when forwarding to " + 

					destinationUrl + " : " + se.getMessage());			

		}

	}

	/**

	 * Forward a request that was received by this servlet on to another JSP

	 * page or servlet to continue handling the request.  In this case, the page

	 * must be referenced in a paramter named "forwardto".  If the qformat is 

	 * provided, the file will be retrieved from that skin.  Otherwise, the file 

	 * will be retrieved from the system default skin.

	 * 

	 * For more specific file location, use: forwardRequest(request,response, destinationUrl, params)

	 * 

	 * @param request

	 *            to be forwarded

	 * @param response

	 *            that can be used for writing output to the client

	 * @param params

	 *            the request parameters.  these will be added to the request.

	 */

	public static void forwardRequest(HttpServletRequest request, HttpServletResponse response, 

			Hashtable<String, String[]> params) throws MetacatUtilException {

		String forwardTos[] = params.get("forwardto");

		if (forwardTos == null || forwardTos[0].equals("")) {

			throw new MetacatUtilException("RequestUtil.forwardRequest - forwardto must be set in parameters when forwarding.");			

		}

		String forwardTo = forwardTos[0];

		String qformat = null;

		String qformats[] = params.get("qformat");

		if (qformats == null || qformats.length == 0) {

			try {

				qformat = PropertyService.getProperty("application.default-style");

			} catch (PropertyNotFoundException pnfe) {

				qformat = "default";

				logMetacat.warn("RequestUtil.forwardRequest - could not get property " + 

						"'application.default-style'. Using 'default'");

			}

		} else {

			qformat = qformats[0];

		}

		String destinationUrl = "/style/skins/" + qformat + "/" + forwardTo;

		destinationUrl += "?" + paramsToQuery(params);

		logMetacat.debug("RequestUtil.forwardRequest - Forwarding request to " + destinationUrl);

		ServletContext servletContext = request.getSession()

				.getServletContext();

		try {

			servletContext.getRequestDispatcher(destinationUrl).forward(request, response);

		} catch (IOException ioe) {

			throw new MetacatUtilException("RequestUtil.forwardRequest - I/O error when forwarding to " + 

					destinationUrl + " : " + ioe.getMessage());			

		} catch (ServletException se) {

			throw new MetacatUtilException("RequestUtil.forwardRequest - Servlet error when forwarding to " + 

					destinationUrl + " : " + se.getMessage());			

		}

	}

	/**

	 * Post a request and return the response body

	 * 

	 * @param httpClient

	 *            The HttpClient to use in the post.  This is passed in because

     * 			  the same client may be used in several posts

	 * @param url

	 *            the url to post to

	 * @param paramMap

	 *            map of parameters to add to the post

	 * @returns a string holding the response body

	 */

	public static String post(HttpClient httpclient, String url,

			HashMap<String, String> paramMap) throws IOException, HttpException {

        httpclient.getParams().setParameter(

        		CoreProtocolPNames.PROTOCOL_VERSION, 

        	    HttpVersion.HTTP_1_1);

    	httpclient.getParams().setParameter(

    			CoreProtocolPNames.HTTP_CONTENT_CHARSET, 

    			encoding );

        HttpPost post = new HttpPost(url);

        //set the params

        List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();

        Iterator<String> keys = paramMap.keySet().iterator();

        while (keys.hasNext()) {

        	String key = keys.next();

        	String value = paramMap.get(key);

        	NameValuePair nvp = new BasicNameValuePair(key, value);

        	nameValuePairs.add(nvp);

        }

        post.setEntity(new UrlEncodedFormEntity(nameValuePairs, encoding));

        //post.setHeader("Cookie", "JSESSIONID="+ sessionId);

        HttpResponse httpResponse = httpclient.execute(post);

        if (httpResponse.getStatusLine().getStatusCode() != -1) {

            InputStream result = httpResponse.getEntity().getContent();

            String contents = IOUtils.toString(result, encoding);

            return contents;

        }

		return null;

	}

	public static String get(String urlString, Hashtable<String, String[]> params)  throws MetacatUtilException {	

		try {

			URL url = new URL(urlString);

			URLConnection urlConn = url.openConnection();

			urlConn.setDoOutput(true);

			PrintWriter pw = new PrintWriter(urlConn.getOutputStream());

			String queryString = paramsToQuery(params);

			logMetacat.debug("Sending get request: " + urlString + "?" + queryString);

			pw.print(queryString);

			pw.close();

			// get the input from the request

			BufferedReader in = 

				new BufferedReader(new InputStreamReader(urlConn.getInputStream()));

			StringBuffer sb = new StringBuffer();

			String line;

			while ((line = in.readLine()) != null) {

				sb.append(line);

			}

			in.close();

			return sb.toString();

		} catch (MalformedURLException mue) {

			throw new MetacatUtilException("URL error when contacting: " + urlString + " : " + mue.getMessage());

		} catch (IOException ioe) {

			throw new MetacatUtilException("I/O error when contacting: " + urlString + " : " + ioe.getMessage());

		} 

	}

	/**

	 * Get a cookie from a request by the cookie name

	 * 

	 * @param request

	 *            the request from which to get the cookie

	 * @param cookieName

	 *            the name of the cookie to look for

	 */

	public static Cookie getCookie(HttpServletRequest request, String cookieName)  {

		Cookie sessionCookies[] = request.getCookies();

		if (sessionCookies == null) {

			return null;

		}

		for (int i = 0; i < sessionCookies.length; i++) {

			if(sessionCookies[i].getName().equals(cookieName)) {

				return sessionCookies[i];

			}

		}	

		return null;

	}

	/**

	 * Get the session data from a request. The Scenarios we can run across

	 * here: 

	 * -- the session id parameter was set in the request parameters 

	 * -- request.getSession returns a new session. There is a chance that the

	 *    session id was set in a cookie. Check for a JSESSIONID cookie and use

	 *    that id if provided. 

	 * -- request.getSession returns a session that is a)

	 *    preexisting or b) new but without a JSESSIONID cookie. Use the session id

	 *    from this session

	 * 

	 * @param request

	 *            the request from which to get the session data

	 * @return the session data object representing the active session for this

	 *         request. If there is no active session, the public session data

	 *         is returned

	 */

	public static SessionData getSessionData(HttpServletRequest request) {

		SessionData sessionData = null;

		String sessionId = null;

		Hashtable<String, String[]> params = getParameters(request);

		if (params.containsKey("sessionid")) {

			// the session id is specified in the request parameters

			sessionId = ((String[]) params.get("sessionid"))[0];

			logMetacat.debug("session ID provided in request properties: " + sessionId);

		} else {

			HttpSession session = request.getSession(true);

			if (session.isNew()) {

				// this is a new session

				Cookie sessionCookie = RequestUtil.getCookie(request, "JSESSIONID");

				if (sessionCookie != null) {

					// and there is a JSESSIONID cookie

					sessionId = sessionCookie.getValue();

					logMetacat.debug("session ID provided in request cookie: "

							+ sessionId);

				}

			}

			if (sessionId == null) {

				// there is an existing session (session is old)

				sessionId = session.getId();

				logMetacat.debug("session ID retrieved from request: " + sessionId);

			}

		}

		// if the session id is registered in SessionService, get the

		// SessionData for it. Otherwise, use the public session.

		if (SessionService.getInstance().isSessionRegistered(sessionId)) {

			logMetacat.debug("retrieving session data from session service "

					+ "for session id " + sessionId);

			sessionData = SessionService.getInstance().getRegisteredSession(sessionId);

		} else {

			logMetacat.debug("using public session.  Given session id is "

					+ "registered: " + sessionId);

			sessionData = SessionService.getInstance().getPublicSession();

		}

		return sessionData;

	}

	/**

	 * Get a cookie from a request by the cookie name

	 * 

	 * @param request

	 *            the request from which to get the cookie

	 * @param cookieName

	 *            the name of the cookie to look for

	 */

	@SuppressWarnings("unchecked")

	public static Hashtable<String, String[]> getParameters(HttpServletRequest request)  {

		Hashtable<String, String[]> params = new Hashtable<String, String[]>();

		Enumeration<String> paramlist = (Enumeration<String>)request.getParameterNames();

		while (paramlist.hasMoreElements()) {

			String name = (String) paramlist.nextElement();

			String[] value = request.getParameterValues(name);

			params.put(name, value);

		}

		return params;

	}

	/**

	 * Add a list of errors to the request. The pages will pick up the errors

	 * and display them where appropriate.

	 * 

	 * @param request

	 *            the request that will get forwarded

	 * @param errorVector

	 *            a list of error strings

	 */

	public static void setRequestErrors(HttpServletRequest request,

			Vector<String> errorVector) {

		request.setAttribute("formErrors", "true");

		request.setAttribute("processingErrors", errorVector);

	}

	/**

	 * Add a list of form errors to the request. The pages will pick up the

	 * errors and display them where appropriate.

	 * 

	 * @param request

	 *            the request that will get forwarded

	 * @param errorVector

	 *            a list of form error strings

	 */

	public static void setRequestFormErrors(HttpServletRequest request,

			Vector<String> errorVector) {

		request.setAttribute("formErrors", "true");

		request.setAttribute("formFieldErrors", errorVector);

	}

	/**

	 * Add a list of success messages to the request. The pages will pick up the

	 * messages and display them where appropriate.

	 * 

	 * @param request

	 *            the request that will get forwarded

	 * @param errorVector

	 *            a list of success message strings

	 */

	public static void setRequestSuccess(HttpServletRequest request,

			Vector<String> successVector) {

		request.setAttribute("formSuccess", "true");

		request.setAttribute("processingSuccess", successVector);

	}

	/**

	 * Add a list of general messages to the request. The pages will pick up the

	 * messages and display them where appropriate.

	 * 

	 * @param request

	 *            the request that will get forwarded

	 * @param errorVector

	 *            a list of general message strings

	 */

	public static void setRequestMessage(HttpServletRequest request,

			Vector<String> messageVector) {

		request.setAttribute("formMessage", "true");

		request.setAttribute("processingMessage", messageVector);

	}

	/**

	 * Add a list of general messages to the request. The pages will pick up the

	 * messages and display them where appropriate.

	 * 

	 * @param request

	 *            the request that will get forwarded

	 * @param errorVector

	 *            a list of general message strings

	 */

	public static void clearRequestMessages(HttpServletRequest request) {

		request.setAttribute("formMessage", null);

		request.setAttribute("formSuccess", null);

		request.setAttribute("formErrors", null);

		request.setAttribute("processingMessage", null);

		request.setAttribute("processingSuccess", null);

		request.setAttribute("formFieldErrors", null);

		request.setAttribute("processingErrors", null);

	}

	/**

	 * Add the user's login id to the session on this request

	 * 

	 * @param request

	 *            the request that will get forwarded

	 * @param userId

	 *            the user's login id

	 */

	public static void setUserId(HttpServletRequest request, String userId) {

		request.getSession().setAttribute("userId", userId);

	}

	private static String paramsToQuery(Hashtable<String, String[]> params) {

		String query = "";

		if (params != null) {

			boolean firstParam = true;

			for (String paramName : params.keySet()) {

				if (firstParam) {

					firstParam = false;

				} else {

					query += "&";

				}

				query += paramName + "=" + params.get(paramName)[0];

			}

		}

		return query;

	}

}