Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: Serhan AKIN $'

 *     '$Date: 2009-06-13 15:28:13 +0300  $'

 *

 * 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.restservice;

import java.io.*;

import java.util.*;

import javax.mail.BodyPart;

import javax.mail.MessagingException;

import javax.mail.internet.MimeMultipart;

import javax.servlet.ServletContext;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.text.DateFormat;

import java.text.ParseException;

import java.text.ParsePosition;

import java.text.SimpleDateFormat;

import org.apache.commons.httpclient.util.DateParser;

import org.apache.commons.io.IOUtils;

import org.apache.log4j.Logger;

import org.dataone.service.exceptions.BaseException;

import org.dataone.service.exceptions.IdentifierNotUnique;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.InvalidSystemMetadata;

import org.dataone.service.exceptions.InvalidToken;

import org.dataone.service.exceptions.NotAuthorized;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.exceptions.UnsupportedType;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.types.*;

import org.jibx.runtime.BindingDirectory;

import org.jibx.runtime.IBindingFactory;

import org.jibx.runtime.IMarshallingContext;

import org.jibx.runtime.IUnmarshallingContext;

import org.jibx.runtime.JiBXException;

import edu.ucsb.nceas.metacat.DBUtil;

import edu.ucsb.nceas.metacat.IdentifierManager;

import edu.ucsb.nceas.metacat.McdbDocNotFoundException;

import edu.ucsb.nceas.metacat.MetacatHandler;

import edu.ucsb.nceas.metacat.client.InsufficientKarmaException;

import edu.ucsb.nceas.metacat.dataone.CrudService;

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

import edu.ucsb.nceas.metacat.util.RequestUtil;

import edu.ucsb.nceas.metacat.util.SessionData;

/**

 * 

 * Implements Earthgrid REST API to Metacat <br/><br/> 

 * 

 * <ul>

 * <li>

 * <h3> EarthGrid Query Service</h3>

 * <ul><li>

 * <h3>Get & Authenticated Get:</h3> 

 * is equal to Metacat's read action and returns a data file having

 * the specified <doc-id> in the resource path. For authenticated Get service, a session id must be provided 

 * in the query string. <br/><br/>

 * 

 * <b>REST URL:</b>	<code>GET, [context-root]/object/[doc-id]?sessionid=[sessionid] </code><br/>

 * <b>Returns:</b> data file <br/><br/>

 * </li>

 * 

 * <li>

 * <h3>Query & Authenticated Query:</h3> 

 * Metacat's equivalent is squery action but this function 

 * receives a Earthgrid query document and returns Earthgrid resultset document by transforming those documents

 * to Metacat's equivalents by the means of Metacat Implementation in Earthgrid library. For authenticated Query service 

 * a session id must be provided in the query string. See Earthgrid (a.k.a. Ecogrid) project for XSD files of 

 * query and resultset documents<br/><br/>

 * 

 * <b>REST URL:</b>	<code>POST, [context-root]/object?sessionid=[sessionid]</code>    <br/>

 * <b>POST Data:</b> Earthgrid query document , Content-type: <code>text/xml</code><br/>

 * <b>Returns:</b> Earthgrid resultset document<br/><br/>

 * 

 * </li>

 * </ul>

 * 

 * </li>

 * 

 * <li>

 * <h3> EarthGrid Authentication Service</h3>

 * <ul><li>

 * <h3>Login: </h3> 

 * Receives username and password parameters in POST data and 

 * returns SessionId (in XML format) or failure message and uses MetacatHandler's handleLoginAction function<br/><br/>

 *  

 * <b>REST URL:</b> <code>POST, [context-root]/session?op=login</code> <br/>

 * <b>POST Data:</b> username=[username]&password=[password], Content-type: <code>application/x-www-form-urlencoded</code>

 * <b>Returns:</b> sessionId in XML format<br/><br/>

 * </li>

 * 

 * <li>

 * <h3>Logout: </h3> 

 * Receives session Id parameters in querystring and returns xml message, calls 

 * MetacatHandler's handleLogoutAction function<br/><br/>

 *  

 * <b>REST URL:</b>	<code>GET, [context-root]/session?op=logout&sessionid=[sessionid]</code>   <br/>

 * <b>Returns:</b> message in XML format<br/><br/>

 * </li>

 * </ul>

 * 

 * <li>

 * <h3>EarthGrid Put Service</h3>

 * 

 * <ul>

 * <li><h3>Update/Insert: </h3>		

 * <br/>

 * <b>REST URL:</b>	<code>PUT, [context-root]/object/[doc-id]?op={update|insert}&sessionid=[sessionid]</code>   <br/>

 * <b>POST Data:</b> document object, Content-type: <code>text/xml</code><br/>

 * <b>Returns:</b> message in XML format<br/><br/>

 * </li>

 * 

 * <li><h3>Delete: </h3>		

 * <br/>

 * <b>REST URL:</b>	<code>DELETE, [context-root]/object/[doc-id]?sessionid=[sessionid]</code>   <br/>

 * <b>Returns:</b> message in XML format<br/><br/>

 * </li>

 * </ul>

 * </li>

 * 

 * <li>

 * <h3>EarthGrid Identifier Service</h3><br/>

 * 

 * <ul>

 * <li><h3>isRegistered: </h3>		<br/>

 * <b>REST URL:</b>	<code>GET, [context-root]/identifier/[doc-id]?op=isregistered</code>   <br/>

 * <b>Returns:</b> message in XML format<br/><br/>

 * </li>

 * <li><h3>getAllDocIds:</h3>		<br/>		

 * <b>REST URL:</b>	<code>GET, [context-root]/identifier?op=getalldocids</code>   <br/>

 * <b>Returns:</b> document id list in XML format<br/><br/>

 * </li>

 * 

 * <li><h3>addLSID Function:</h3> 

 * Metacat does not support this function 		<br/>

 * <b>REST URL:</b>	<code>PUT, [context-root]/identifier/[doc-id]</code>   <br/>

 * <b>Returns:</b> error message in XML format<br/><br/>

 * </li>

 * 

 * <li><h3>getNextRevision:</h3>		<br/>

 * <b>REST URL:</b>	<code>GET, [context-root]/identifier/[doc-id]?op=getnextrevision</code>   <br/>

 * <b>Returns:</b> message in XML format<br/><br/>

 * </li>

 * 

 * <li><h3>getNextObject:</h3>		<br/>

 * <b>REST URL:</b>	<code>GET, [context-root]/identifier?op=getnextobject&scope=[scope]</code>   <br/>

 * <b>Returns:</b> message in XML format<br/><br/>

 * </li>

 * 

 * </li>

 * </ul>

 * 

 */

public class ResourceHandler {

    /**HTTP Verb GET*/

    public static final byte GET = 1;

    /**HTTP Verb POST*/

    public static final byte POST = 2;

    /**HTTP Verb PUT*/

    public static final byte PUT = 3;

    /**HTTP Verb DELETE*/

    public static final byte DELETE = 4;

    /*

     * API Resources

     */

    private static final String RESOURCE_OBJECTS = "object";

    private static final String RESOURCE_META = "meta";

    private static final String RESOURCE_SESSION = "session";

    private static final String RESOURCE_IDENTIFIER = "identifier";

    private static final String RESOURCE_LOG = "log";

    /*

     * API Functions used as URL parameters

     */

    private static final String FUNCTION_KEYWORD = "op";

    private static final String FUNCTION_NAME_LOGIN = "login";

    private static final String FUNCTION_NAME_LOGOUT = "logout";

    private static final String FUNCTION_NAME_SET_ACCESS = "setaccess";

    private static final String FUNCTION_NAME_ISREGISTERED = "isregistered";

    private static final String FUNCTION_NAME_GETALLDOCS = "getalldocids";

    private static final String FUNCTION_NAME_GETNEXTREV = "getnextrevision";

    private static final String FUNCTION_NAME_GETNEXTOBJ = "getnextobject";

    private static final String FUNCTION_NAME_INSERT = "insert";

    private static final String FUNCTION_NAME_UPDATE = "update";

    private static final String FUNCTION_NAME_GENERATE_MISSING_SYSTEM_METADATA = "generatemissingsystemmetadata";

    private static final DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");

    private ServletContext servletContext;

    private Logger logMetacat;

    private MetacatHandler handler;

    private HttpServletRequest request;

    private HttpServletResponse response;

    private String username;

    private String password;

    private String sessionId;

    private String[] groupNames;

    private Hashtable<String, String[]> params;

    /**Initializes new instance by setting servlet context,request and response*/

    public ResourceHandler(ServletContext servletContext,

            HttpServletRequest request, HttpServletResponse response) {

        this.servletContext = servletContext;

        this.request = request;

        this.response = response;

    }

    /**

     * This function is called from REST APU servlet and handles each request to the servlet 

     * 

     * @param httpVerb (GET, POST, PUT or DELETE)

     */

    public void handle(byte httpVerb) {

        logMetacat = Logger.getLogger(ResourceHandler.class);

        try {

            String resource = request.getServletPath();

            String verb = "";

            System.out.println("handling verb " + httpVerb + " request with resource " + resource);

            boolean status = false;

            loadSessionData();

            if (resource != null) {

            	resource = request.getServletPath().substring(1);

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

            	initParams();

            	Timer timer = new Timer();

            	handler = new MetacatHandler(timer);

            	if (resource.equals(RESOURCE_SESSION) && 

            			httpVerb == POST && 

            			params.get(FUNCTION_KEYWORD) != null) {

            		//System.out.println("function_keyword: " + params.get(FUNCTION_KEYWORD)[0]);

            		if (params.get(FUNCTION_KEYWORD)[0].equals(FUNCTION_NAME_LOGIN)) {

            			login();

            			status = true;

            		} else if (params.get(FUNCTION_KEYWORD)[0].equals(FUNCTION_NAME_LOGOUT)) {

            			logout();

            			status = true;

            		} else if (params.get(FUNCTION_KEYWORD)[0].equals(FUNCTION_NAME_SET_ACCESS)) {

            			setaccess();

            			status = true;

            			//System.out.println("done setting access");

            		}

            	} else if (resource.equals(RESOURCE_META)) {

            		if(params != null && params.get(FUNCTION_KEYWORD) != null &&

            				params.get(FUNCTION_KEYWORD)[0].equals(FUNCTION_NAME_GENERATE_MISSING_SYSTEM_METADATA))

            		{ //generate system metadata for any object that is

            			//a) not system metadata itself

            			//b) does not already have a system metadata id in the systemmetadata table

            			//c) not a BIN object (data)

            		    //TODO: check if we need this anymore.  Might be superceded

            		    //by MetacatPopulator

            			generateMissingSystemMetadata();

            			status = true;

            		}

            		else

            		{

            			String objectId = request.getPathInfo();

            			if (objectId != null && objectId.length() > 1) 

            			{

            				objectId = request.getPathInfo().substring(1);

            			}

            			getSystemMetadataObject(objectId);

            			status = true;

            		}

            	} else if (resource.equals(RESOURCE_OBJECTS)) {

            		logMetacat.debug("D1 Rest: Starting resource processing...");

            		loadSessionData();

            		String objectId = request.getPathInfo();

            		if (objectId != null && objectId.length() > 1) 

            		{

            			objectId = request.getPathInfo().substring(1);

            		}

            		else

            		{

            			objectId = null;

            		}

            		logMetacat.debug("verb:" + httpVerb);

            		if (httpVerb == GET) {

            			getObject(objectId);

            			status = true;

            		} else if (httpVerb == POST) {

            			putObject(objectId, FUNCTION_NAME_INSERT);

            			status = true;

            		} else if (httpVerb == PUT) {

            			putObject(objectId, FUNCTION_NAME_UPDATE);

            			status = true;

            		} else if (httpVerb == DELETE) {

            			deleteObject(objectId);

            			status = true;

            		}

            	} else if (resource.equals(RESOURCE_IDENTIFIER)) {

            		String identifierId = request.getPathInfo();

            		if (identifierId != null && identifierId.length() > 1)

            			identifierId = request.getPathInfo().substring(1); //trim the slash

            		if (httpVerb == GET) {

            			String op = params.get(FUNCTION_KEYWORD)[0];

            			if (op.equals(FUNCTION_NAME_ISREGISTERED)) {

            				isRegistered(identifierId);

            				status = true;

            			} else if (op.equals(FUNCTION_NAME_GETALLDOCS)) {

            				getAllDocIds();

            				status = true;

            			} else if (op.equals(FUNCTION_NAME_GETNEXTREV)) {

            				getNextRevision(identifierId);

            				status = true;

            			} else if (op.equals(FUNCTION_NAME_GETNEXTOBJ)) {

            				getNextObject();

            				status = true;

            			} 

            		} else if (httpVerb == PUT) {

            			//Earthgrid API > Identifier Service > addLSID Function 

            			printError(

            					"This method is not supported by metacat.  To "

            					+ "add a new LSID, add a document to metacat.",

            					response);

            			status = true;

            		}

            	} else if (resource.equals(RESOURCE_LOG)) {

            		//handle log events

            		if(httpVerb == GET)

            		{

            			getLog();

            			status = true;

            		}

            		else

            		{

            		    //change to D1 spec for specifying which http methods are allowed for a resource

            			printError("POST, PUT, DELETE is not supported for logs.", response);

            			status = true;

            		}

            	}

            	if (!status)

            		printError("Incorrect parameters!", response);

            } else {

            	printError("Incorrect resource!", response);

            }

        } catch (Exception e) {

        	logMetacat.error(e.getMessage());

        	e.printStackTrace();

        }

    }

    /**

     * get the logs from the CrudService based on passed params.  Available 

     * params are token, fromDate, toDate, event.  See 

     * http://mule1.dataone.org/ArchitectureDocs/mn_api_crud.html#MN_crud.getLogRecords

     * for more info

     */

    private void getLog()

    {

        OutputStream out = null;

        try

        {

            out = response.getOutputStream();

            response.setContentType("text/xml");

            AuthToken token = new AuthToken(sessionId);

            String fromDateS = params.get("fromDate")[0];

            System.out.println("param fromDateS: " + fromDateS);

            Date fromDate = null;

            String toDateS = params.get("toDate")[0];

            System.out.println("param toDateS: " + toDateS);

            Date toDate = null;

            String eventS = params.get("event")[0];

            Event event = null;

            if(fromDateS != null)

            {

                //fromDate = dateFormat.parse(fromDateS);

                fromDate = parseDateAndConvertToGMT(fromDateS);

            }

            if(toDateS != null)

            {

                //toDate = dateFormat.parse(toDateS);

                toDate = parseDateAndConvertToGMT(toDateS);

            }

            if(eventS != null)

            {

                event = Event.convert(eventS);

            }

            System.out.println("fromDate: " + fromDate + " toDate: " + toDate);

            System.out.println("calling crudservice.getLogRecords");

            Log log = CrudService.getInstance().getLogRecords(token, fromDate, toDate, event);

            serializeServiceType(Log.class, log, out);

        }

        catch(Exception e)

        {

            String msg = "Could not get logs from CrudService: " + e.getMessage();

            ServiceFailure sf = new ServiceFailure("1490", msg);

            logMetacat.error(msg);

            e.printStackTrace();

            serializeException(sf, out);

        }

    }

    /**

     *  copies request parameters to a hashtable which is given as argument to native metacathandler functions  

     */

    private void initParams() {

        String name = null;

        String[] value = null;

        Enumeration paramlist = request.getParameterNames();

        while (paramlist.hasMoreElements()) {

            name = (String) paramlist.nextElement();

            value = request.getParameterValues(name);

            params.put(name, value);

        }

    }

    /**

     * 

     * Load user details of metacat session from the request 

     * 

     */

    private void loadSessionData()

      throws Exception

    {

        SessionData sessionData = RequestUtil.getSessionData(request);

        try

        {

            username = null;

            password = null;

            groupNames = null;

            sessionId = null;

            boolean validSession = false;

            SessionService ss = SessionService.getInstance();

            System.out.println("sessionData: " + sessionData);

            if(sessionData == null)

            {

                username = "public";

                sessionId = "0";

                System.out.println("sessiondata is null.  Creating a public session.");

                return;

            }

            System.out.println("username: " + sessionData.getUserName());

            System.out.println("sessionid: " + sessionData.getId());

            //validate the session

            if(ss.isSessionRegistered(sessionData.getId()) && 

               !(sessionData.getUserName().equals("public") || sessionData.getId().equals("0")))

            {

                validSession = true;

            }

            if(validSession)

            {

                //if the session is valid, set these variables

                username = sessionData.getUserName();

                password = sessionData.getPassword();

                groupNames = sessionData.getGroupNames();

                sessionId = sessionData.getId();

                System.out.println("setting sessionid to " + sessionId);

                System.out.println("username: " + username);

            }

            //if the session is not valid or the username is null, set

            //username to public

            if (username == null) 

            {

                System.out.println("setting username to public.");

                username = "public";

            }

        }

        catch(Exception e)

        {

            e.printStackTrace();

            throw new Exception("Could not load the session data: " + e.getMessage());

        }

    }

    /**

     * generate missing system metadata for any science metadata objects

     * that don't already have it. https://trac.dataone.org/ticket/591

     * 

     * called with POST meta/?op=generatemissingsystemmetadata

     */

    private void generateMissingSystemMetadata()

    {

        AuthToken token = new AuthToken(sessionId);

        CrudService.getInstance().generateMissingSystemMetadata(token);

    }

    /**

     *  Earthgrid API > Identifier Service > isRegistered Function : 

     *  calls MetacatHandler > handleIdIsRegisteredAction

     * @param guid

     * @throws IOException

     */

    private void isRegistered(String guid) throws IOException

    {

        // Look up the localId for this guid

        IdentifierManager im = IdentifierManager.getInstance();

        String localId = "";

        try {

            localId = im.getLocalId(guid);

        } catch (McdbDocNotFoundException e) {

            // TODO: Need to return the proper DataONE exception

        }

        params.put("docid", new String[] { localId });

        PrintWriter out = response.getWriter();

        response.setContentType("text/xml");

        handler.handleIdIsRegisteredAction(out, params, response);

        out.close();

    }

    /**

     * Earthgrid API > Identifier Service > getAllDocIds Function : 

     * calls MetacatHandler > handleGetAllDocidsAction

     * @throws IOException

     */

    private void getAllDocIds() throws IOException {

        PrintWriter out = response.getWriter();

        response.setContentType("text/xml");

        handler.handleGetAllDocidsAction(out, params, response);

        out.close();

    }

    /**

     * Earthgrid API > Identifier Service > getNextRevision Function : 

     * calls MetacatHandler > handleGetRevisionAndDocTypeAction

     * @param guid

     * @throws IOException

     */

    private void getNextRevision(String guid) throws IOException 

    {

        params.put("docid", new String[] { guid });

        PrintWriter out = response.getWriter();

        response.setContentType("text/xml");

        //handler.handleGetRevisionAndDocTypeAction(out, params);

        try {

            // Make sure there is a docid

            if (guid == null || guid.equals("")) {

                throw new Exception("User didn't specify docid!");

            }

            // Look up the localId for this guid

            IdentifierManager im = IdentifierManager.getInstance();

            String localId = "";

            try {

                localId = im.getLocalId(guid);

            } catch (McdbDocNotFoundException e) {

                // TODO: Need to return the proper DataONE exception

            }

            // Create a DBUtil object

            DBUtil dbutil = new DBUtil();

            // Get a rev and doctype

            String revAndDocType = dbutil

                    .getCurrentRevisionAndDocTypeForGivenDocument(localId);

            int revision = Integer.parseInt(revAndDocType.split(";")[0]) + 1;

            out.println("<?xml version=\"1.0\"?>");

            out.print("<next-revision>");

            out.print(revision);

            out.print("</next-revision>");

        } catch (Exception e) {

            // Handle exception

            out.println("<?xml version=\"1.0\"?>");

            out.println("<error>");

            out.println(e.getMessage());

            out.println("</error>");

        }

        out.close();

    }

    /**

     * Earthgrid API > Identifier Service > getNextObject Function : 

     * calls MetacatHandler > handleGetMaxDocidAction

     * @throws IOException

     */

    private void getNextObject() throws IOException {

        PrintWriter out = response.getWriter();

        response.setContentType("text/xml");

        handler.handleGetMaxDocidAction(out, params, response);

        out.close();

    }

    /**

     * Implements REST version of DataONE CRUD API --> get

     * @param guid ID of data object to be read

     */

    private void getObject(String guid) {

        CrudService cs = CrudService.getInstance();

        cs.setParamsFromRequest(request);

        AuthToken token = new AuthToken(sessionId);

        OutputStream out = null;

        try {

            out = response.getOutputStream();

            response.setContentType("text/xml");

            if(guid != null)

            { //get a specific document                

                Identifier id = new Identifier();

                id.setValue(guid);

                try

                {

                    if(token == null)

                    {

                        token = new AuthToken("Public");

                    }

                    InputStream data = cs.get(token, id);

                    IOUtils.copyLarge(data, response.getOutputStream());

                }

                catch(InvalidToken it)

                {

                    serializeException(it, out); 

                }

                catch(ServiceFailure sf)

                {

                    serializeException(sf, out); 

                }

                catch(NotAuthorized na)

                {

                    serializeException(na, out); 

                }

                catch(NotFound nf)

                {

                    serializeException(nf, out); 

                }

                catch(NotImplemented ni)

                {

                    serializeException(ni, out); 

                }

                catch(Exception e)

                {

                    System.out.println("Error with Crud.get().  " +

                            "If this is an 'Exception producing data' error, " +

                            "go to CrudService.get() for better debugging.  " +

                            "Here's the error: " + e.getMessage());

                    e.printStackTrace();

                    ServiceFailure sf = new ServiceFailure("1030", 

                            "IO Error in ResourceHandler.getObject: " + e.getMessage());

                    serializeException(sf, out); 

                }

            }

            else

            { //call listObjects with specified params

                Date startTime = null;

                Date endTime = null;

                ObjectFormat objectFormat = null;

                boolean replicaStatus = false;

                int start = 0;

                //TODO: make the max count into a const

                int count = 1000;

                Enumeration paramlist = request.getParameterNames();

                while (paramlist.hasMoreElements()) 

                { //parse the params and make the crud call

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

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

                    /*for(int i=0; i<value.length; i++)

                    {

                        System.out.println("name: " + name + " value: " + value[i]);

                    }*/

                    if(name.equals("startTime") && value != null)

                    {

                        try

                        {

                          //startTime = dateFormat.parse(value[0]);

                            startTime = parseDateAndConvertToGMT(value[0]);

                        }

                        catch(Exception e)

                        {  //if we can't parse it, just don't use the startTime param

                            System.out.println("Could not parse startTime: " + value[0]);

                            startTime = null;

                        }

                    }

                    else if(name.equals("endTime") && value != null)

                    {

                        try

                        {

                          //endTime = dateFormat.parse(value[0]);

                            endTime = parseDateAndConvertToGMT(value[0]);

                        }

                        catch(Exception e)

                        {  //if we can't parse it, just don't use the endTime param

                            System.out.println("Could not parse endTime: " + value[0]);

                            endTime = null;

                        }

                    }

                    else if(name.equals("objectFormat") && value != null)

                    {

                        objectFormat = ObjectFormat.convert(value[0]);

                    }

                    else if(name.equals("replicaStatus") && value != null)

                    {

                        if(value != null && 

                           value.length > 0 && 

                           (value[0].equals("true") || value[0].equals("TRUE") || value[0].equals("YES")))

                        {

                            replicaStatus = true;

                        }

                    }

                    else if(name.equals("start") && value != null)

                    {

                        start = new Integer(value[0]).intValue();

                    }

                    else if(name.equals("count") && value != null)

                    {

                        count = new Integer(value[0]).intValue();

                    }

                }

                //make the crud call

                /*System.out.println("token: " + token + " startTime: " + startTime +

                        " endtime: " + endTime + " objectFormat: " + 

                        objectFormat + " replicaStatus: " + replicaStatus + 

                        " start: " + start + " count: " + count);

                */

                ObjectList ol = cs.listObjects(token, startTime, endTime, 

                        objectFormat, replicaStatus, start, count);

                //TODO: why is this calling this twice?

                //ol = cs.listObjects(token, startTime, endTime, objectFormat, replicaStatus, start, count);

                StringReader sr = new StringReader(ol.toString());                

                out = response.getOutputStream();      

                response.setContentType("text/xml");

                // Serialize and write it to the output stream

                try {

                    serializeServiceType(ObjectList.class, ol, out);

                } catch (JiBXException e) {

                    throw new ServiceFailure("1190", "Failed to serialize ObjectList: " + e.getMessage());

                }

            }

        } catch (BaseException e) {

                serializeException(e, out);

        } catch (IOException e) {

            e.printStackTrace();

            ServiceFailure sf = new ServiceFailure("1030", 

                    "IO Error in ResourceHandler.getObject: " + e.getMessage());

            serializeException(sf, out); 

        } catch(NumberFormatException ne) {

            InvalidRequest ir = new InvalidRequest("1030", "Invalid format for parameter: " + ne.getMessage());

            serializeException(ir, out);

        } catch (Exception e) {

            e.printStackTrace();

            ServiceFailure sf = new ServiceFailure("1030", 

                    "Exception " + e.getClass().getName() + " raised while handling listObjects request: " + 

                    e.getMessage());

            serializeException(sf, out);

        }

    }

    /**

     * parse a date and return it in GMT if it ends with a 'Z'

     * @param date

     * @return

     * @throws ParseException

     */

    private Date parseDateAndConvertToGMT(String date) throws ParseException

    {

        try

        {   //the format we want

            return dateFormat.parse(date);

        }

        catch(java.text.ParseException pe)

        {   //try another legacy format

            DateFormat dateFormat2 = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss'Z'");

            dateFormat2.setTimeZone(TimeZone.getTimeZone("GMT-0"));

            return dateFormat2.parse(date);

        }    

        /*System.out.println("Parsing date " + date);

        Date d = dateFormat.parse(date);

        if(date.endsWith("Z"))

        {

            Calendar lTime = Calendar.getInstance();

            lTime.setTime(d);

            Calendar zTime = Calendar.getInstance(TimeZone.getTimeZone("GMT-0"));

            zTime.set(Calendar.MONTH, lTime.get(Calendar.MONTH));

            zTime.set(Calendar.DATE, lTime.get(Calendar.DATE));

            zTime.set(Calendar.YEAR, lTime.get(Calendar.YEAR));

            zTime.set(Calendar.HOUR, lTime.get(Calendar.HOUR));

            zTime.set(Calendar.MINUTE, lTime.get(Calendar.MINUTE));

            zTime.set(Calendar.SECOND, lTime.get(Calendar.SECOND));

            System.out.println("date parsed to " + zTime.getTime());

            return zTime.getTime();

        }

        System.out.println("date parsed, but not converted. returned as " + d);

        return d;*/

    }

    /**

     * Implements REST version of DataONE CRUD API --> getSystemMetadata

     * @param guid ID of data object to be read

     */

    private void getSystemMetadataObject(String guid) {

        CrudService cs = CrudService.getInstance();

        cs.setParamsFromRequest(request);

        AuthToken token = new AuthToken(sessionId);

        OutputStream out = null;

        try {

            response.setContentType("text/xml");

            out = response.getOutputStream();

            Identifier id = new Identifier();

            id.setValue(guid);

            SystemMetadata sysmeta = cs.getSystemMetadata(token, id);

            // Serialize and write it to the output stream

            try {

                //TODO: look at the efficiency of this method.  The system metadata

                //is read from metacat (in CrudService) as xml, then serialized

                //to a SystemMetadat object, then returned here, then serizlized

                //back to XML to be sent to the response.

                serializeServiceType(SystemMetadata.class, sysmeta, out);

            } catch (JiBXException e) {

                throw new ServiceFailure("1190", "Failed to serialize SystemMetadata: " + e.getMessage());

            }

        } catch (BaseException e) {

                serializeException(e, out);

        } catch (IOException e) {

            ServiceFailure sf = new ServiceFailure("1030", 

                    "Error in ResourceHandler.getSystemMetadataObject: " + e.getMessage());

            serializeException(sf, out);

        } finally {

            IOUtils.closeQuietly(out);

        }

    }

    /**

     * serialize an object of type to out

     * @param type the class of the object to serialize (i.e. SystemMetadata.class)

     * @param object the object to serialize

     * @param out the stream to serialize it to

     * @throws JiBXException

     */

    private void serializeServiceType(Class type, Object object, OutputStream out)

      throws JiBXException

    {

        IBindingFactory bfact = BindingDirectory.getFactory(type);

        IMarshallingContext mctx = bfact.createMarshallingContext();

        mctx.marshalDocument(object, "UTF-8", null, out);

    }

    /**

     * deserialize an object of type from is

     * @param type the class of the object to serialize (i.e. SystemMetadata.class)

     * @param is the stream to deserialize from

     * @throws JiBXException

     */

    private Object deserializeServiceType(Class type, InputStream is)

      throws JiBXException

    {

        IBindingFactory bfact = BindingDirectory.getFactory(type);

        IUnmarshallingContext uctx = bfact.createUnmarshallingContext();

        Object o = (Object) uctx.unmarshalDocument(is, null);

        return o;

    }

    /**

     * Earthgrid API > Query Service > Query Function : translates ecogrid query document to metacat query 

     * then calls DBQuery > createResultDocument function and then again translate resultset to ecogrid resultset

     * 

     * NOTE:

     *      This is the only method that uses EcoGrid classes for its implementation.  

     *      It does so because it takes an EcoGrid Query as input, and outputs an

     *      EcoGrid ResultSet document.  These documents are parsed by the auto-generated

     *      EcoGrid classes from axis, and so we link to them here rather than re-inventing them.

     *      This creates a circular dependency, because the Metacat classes are needed

     *      to build the EcoGrid implementation, and the EcoGrid jars are needed to build this query()

     *      method.  This circularity could be resolved by moving the EcoGrid classes

     *      to Metacat directly.  As we transition away from EcoGrid SOAP methods in

     *      favor of these REST interfaces, this circular dependency can be eliminated.

     *        

     * @throws Exception

     */

    private void query() throws Exception {

        /*  This block commented out because of the EcoGrid circular dependency.

         *  For now, query will not be supported until the circularity can be

         *  resolved, probably by moving the ecogrid query syntax transformers

         *  directly into the Metacat codebase.  MBJ 2010-02-03

        try {

            EcogridQueryParser parser = new EcogridQueryParser(request

                    .getReader());