/src/edu/ucsb/nceas/metacat/dataone/CrudService.java - Annotate - Metacat - Ecoinformatics Redmine

metacat/src/edu/ucsb/nceas/metacat/dataone/CrudService.java @ 5921

-            jones
+/**
  *  '$RCSfile$'
  *  Copyright: 2000 Regents of the University of California and the
  *              National Center for Ecological Analysis and Synthesis
+ *
-            jones
+ *   '$Author: $'
-            jones
+ *     '$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.dataone;
-            jones
+import java.io.ByteArrayOutputStream;
-            jones
+import java.io.File;
-            berkley
+import java.io.FileInputStream;
-            jones
+import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
-            jones
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-            jones
+import java.security.NoSuchAlgorithmException;
-            jones
+import java.sql.SQLException;
-            berkley
+import java.text.DateFormat;
-            jones
+import java.util.Calendar;
 import java.util.Date;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.List;
 import java.util.TimeZone;
 import java.util.Timer;
 import java.util.TimerTask;
 import java.util.Vector;
             jones
 import javax.servlet.http.HttpServletRequest;
-            jones
+import org.apache.commons.io.IOUtils;
 import org.apache.log4j.Logger;
-            jones
+import org.dataone.service.exceptions.BaseException;
-            jones
+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.NotFound;
 import org.dataone.service.exceptions.NotImplemented;
 import org.dataone.service.exceptions.ServiceFailure;
 import org.dataone.service.exceptions.UnsupportedType;
 import org.dataone.service.mn.MemberNodeCrud;
-            jones
+import org.dataone.service.types.AuthToken;
 import org.dataone.service.types.Checksum;
 import org.dataone.service.types.ChecksumAlgorithm;
 import org.dataone.service.types.DescribeResponse;
 import org.dataone.service.types.Event;
 import org.dataone.service.types.Identifier;
 import org.dataone.service.types.Log;
 import org.dataone.service.types.LogEntry;
 import org.dataone.service.types.NodeReference;
 import org.dataone.service.types.ObjectFormat;
 import org.dataone.service.types.ObjectList;
 import org.dataone.service.types.Principal;
 import org.dataone.service.types.SystemMetadata;
 import org.dataone.service.types.util.ServiceTypeUtil;
-            jones
+import org.jibx.runtime.BindingDirectory;
 import org.jibx.runtime.IBindingFactory;
 import org.jibx.runtime.IMarshallingContext;
-            jones
+import org.jibx.runtime.IUnmarshallingContext;
-            jones
+import org.jibx.runtime.JiBXException;
             jones
-            berkley
+import edu.ucsb.nceas.metacat.AccessionNumber;
-            jones
+import edu.ucsb.nceas.metacat.AccessionNumberException;
 import edu.ucsb.nceas.metacat.DocumentImpl;
 import edu.ucsb.nceas.metacat.EventLog;
-            jones
+import edu.ucsb.nceas.metacat.IdentifierManager;
 import edu.ucsb.nceas.metacat.McdbDocNotFoundException;
 import edu.ucsb.nceas.metacat.McdbException;
 import edu.ucsb.nceas.metacat.MetacatHandler;
 import edu.ucsb.nceas.metacat.client.InsufficientKarmaException;
-            berkley
+import edu.ucsb.nceas.metacat.client.rest.MetacatRestClient;
-            jones
+import edu.ucsb.nceas.metacat.properties.PropertyService;
 import edu.ucsb.nceas.metacat.replication.ForceReplicationHandler;
-            jones
+import edu.ucsb.nceas.metacat.service.SessionService;
-            jones
+import edu.ucsb.nceas.metacat.util.DocumentUtil;
-            jones
+import edu.ucsb.nceas.metacat.util.SessionData;
 import edu.ucsb.nceas.utilities.ParseLSIDException;
 import edu.ucsb.nceas.utilities.PropertyNotFoundException;
 /**
+ *
  * Implements DataONE MemberNode CRUD API for Metacat.
+ *
  * @author Matthew Jones
  */
-            berkley
+public class CrudService implements MemberNodeCrud
+{
-            berkley
+    private static CrudService crudService = null;
             jones
     private MetacatHandler handler;
     private Hashtable<String, String[]> params;
-            berkley
+    private Logger logMetacat = null;
     private Logger logCrud = null;
             berkley
     private String metacatUrl;
             berkley
-            jones
+    /**
-            berkley
+     * singleton accessor
      */
-            berkley
+    public static CrudService getInstance()
             berkley
       if(crudService == null)
+      {
         crudService = new CrudService();
+      }
       return crudService;
+    }
     /**
-            berkley
+     * Constructor, private for singleton access
-            jones
+     */
-            berkley
+    private CrudService() {
-            berkley
+        logMetacat = Logger.getLogger(CrudService.class);
-            berkley
+        logCrud = Logger.getLogger("DataOneLogger");
-            berkley
+        try
+        {
             String server = PropertyService.getProperty("server.name");
             String port = PropertyService.getProperty("server.httpPort");
             String context = PropertyService.getProperty("application.context");
-            berkley
+            metacatUrl = "http://" + server + ":" + port + "/" + context + "/d1";
-            berkley
+            logMetacat.debug("Initializing CrudService with url " + metacatUrl);
+        }
         catch(Exception e)
+        {
             logMetacat.error("Could not find servlet url in CrudService: " + e.getMessage());
             e.printStackTrace();
             throw new RuntimeException("Error getting servlet url in CrudService: " + e.getMessage());
+        }
         params = new Hashtable<String, String[]>();
         handler = new MetacatHandler(new Timer());
             jones
             berkley
-            jones
+    /**
-            berkley
+     * return the context url CrudService is using.
-            jones
+     */
-            berkley
+    public String getContextUrl()
+    {
         return metacatUrl;
+    }
     /**
-            berkley
+     * Set the context url that this service uses.  It is normally not necessary
      * to call this method unless you are trying to connect to a server other
      * than the one in which this service is installed.  Otherwise, this value is
      * taken from the metacat.properties file (server.name, server.port, application.context).
      */
     public void setContextUrl(String url)
+    {
         metacatUrl = url;
+    }
     /**
-            berkley
+     * set the params for this service from an HttpServletRequest param list
      */
     public void setParamsFromRequest(HttpServletRequest request)
+    {
-            jones
+        @SuppressWarnings("unchecked")
         Enumeration<String> paramlist = request.getParameterNames();
-            jones
+        while (paramlist.hasMoreElements()) {
-            berkley
+            String name = (String) paramlist.nextElement();
             String[] value = (String[])request.getParameterValues(name);
-            jones
+            params.put(name, value);
+        }
+    }
-            berkley
+    /**
-            berkley
+     * Authenticate against metacat and get a token.
      * @param username
      * @param password
      * @return
      * @throws ServiceFailure
      */
     public AuthToken authenticate(String username, String password)
       throws ServiceFailure
+    {
-            berkley
+        /* TODO:
          * This method is not in the original D1 crud spec.  It is highly
          * metacat centric.  Higher level decisions need to be made on authentication
          * interfaces for D1 nodes.
          */
-            berkley
+        try
+        {
             MetacatRestClient restClient = new MetacatRestClient(getContextUrl());
             String response = restClient.login(username, password);
             String sessionid = restClient.getSessionId();
             SessionService sessionService = SessionService.getInstance();
             sessionService.registerSession(new SessionData(sessionid, username, new String[0], password, "CrudServiceLogin"));
             AuthToken token = new AuthToken(sessionid);
-            berkley
+            EventLog.getInstance().log(metacatUrl,
-            berkley
+                    username, null, "authenticate");
-            berkley
+            logCrud.info("authenticate");
-            berkley
+            return token;
+        }
         catch(Exception e)
+        {
-            berkley
+            throw new ServiceFailure("1620", "Error authenticating with metacat: " + e.getMessage());
             berkley
+    }
     /**
-            berkley
+     * set the parameter values needed for this request
      */
     public void setParameter(String name, String[] value)
+    {
         params.put(name, value);
+    }
-            berkley
+    /**
      * Generate SystemMetadata for any object in the object store that does
      * not already have it.  SystemMetadata documents themselves, are, of course,
      * exempt.  This is a utility method for migration of existing object
      * stores to DataONE where SystemMetadata is required for all objects.  See
      * https://trac.dataone.org/ticket/591
             berkley
      * @param token an authtoken with appropriate permissions to read all
      * documents in the object store.  To work correctly, this should probably
      * be an adminstrative credential.
-            berkley
+     */
-            jones
+    public void generateMissingSystemMetadata(AuthToken token) {
-            berkley
+        IdentifierManager im = IdentifierManager.getInstance();
-            berkley
+        //get the list of ids with no SM
-            jones
+        List<String> idList = im.getLocalIdsWithNoSystemMetadata();
         for (String localId : idList) {
             //for each id, add a system metadata doc
             generateMissingSystemMetadata(token, localId);
+        }
         logCrud.info("generateMissingSystemMetadata(token)");
+    }
     /**
      * Generate SystemMetadata for a particular object with identifier localId.
      * This is a utility method for migration of existing objects
      * to DataONE where SystemMetadata is required for all objects.
+     *
      * @param token an authtoken with appropriate permissions to read all
      *        documents in the object store.  To work correctly, this should
      *        be an adminstrative credential.
      * @param localId the identifier of the object to be processed
      */
     public void generateMissingSystemMetadata(AuthToken token, String localId) {
         System.out.println("Creating SystemMetadata for localId " + localId);
         try {
             //generate required system metadata fields from the document
             SystemMetadata sm = createSystemMetadata(localId, token);
             //insert the systemmetadata object
             SessionData sessionData = getSessionData(token);
             String smlocalid = insertSystemMetadata(sm, sessionData);
             System.out.println("setting access on SM doc with localid " + smlocalid);
             handler.setAccess(metacatUrl, sessionData.getUserName(), smlocalid, "public", "4", "allow", "allowFirst");
             String username = "public";
             if (sessionData != null) {
                 username = sessionData.getUserName();
             berkley
-            jones
+            EventLog.getInstance().log(metacatUrl, username, localId, "generateMissingSystemMetadata");
         } catch (Exception e) { // TODO: Please don't catch Exception -- it masks bad things
             e.printStackTrace();
             System.out.println("Exception generating missing system metadata: " + e.getMessage());
             logMetacat.error("Could not generate missing system metadata: " + e.getMessage());
             berkley
-            jones
+        logCrud.info("generateMissingSystemMetadata(token, localId)");
             berkley
-            berkley
+    /**
-            berkley
+     * create an object via the crud interface
-            berkley
+     */
-            jones
+    public Identifier create(AuthToken token, Identifier guid,
-            jones
+            InputStream object, SystemMetadata sysmeta) throws InvalidToken,
             ServiceFailure, NotAuthorized, IdentifierNotUnique, UnsupportedType,
             InsufficientResources, InvalidSystemMetadata, NotImplemented {
-            jones
+        logMetacat.debug("Starting CrudService.create()...");
-            jones
+        // authenticate & get user info
         SessionData sessionData = getSessionData(token);
-            berkley
+        String username = "public";
         String[] groups = null;
         if(sessionData != null)
+        {
             username = sessionData.getUserName();
             groups = sessionData.getGroupNames();
+        }
-            berkley
+        String localId = null;
             jones
-            berkley
+        if (username == null || username.equals("public"))
+        {
-            berkley
+            //TODO: many of the thrown exceptions do not use the correct error codes
             //check these against the docs and correct them
-            berkley
+            throw new NotAuthorized("1100", "User " + username + " is not authorized to create content." +
-            berkley
+                    "  If you are not logged in, please do so and retry the request.");
+        }
-            jones
+        // verify that guid == SystemMetadata.getIdentifier()
-            jones
+        logMetacat.debug("Comparing guid|sysmeta_guid: " + guid.getValue() + "|" + sysmeta.getIdentifier().getValue());
-            jones
+        if (!guid.getValue().equals(sysmeta.getIdentifier().getValue())) {
-            berkley
+            throw new InvalidSystemMetadata("1180",
-            berkley
+                "GUID in method call (" + guid.getValue() + ") does not match GUID in system metadata (" +
                 sysmeta.getIdentifier().getValue() + ").");
             jones
             jones
         logMetacat.debug("Checking if identifier exists...");
         // Check that the identifier does not already exist
-            berkley
+        IdentifierManager im = IdentifierManager.getInstance();
-            jones
+        if (im.identifierExists(guid.getValue())) {
-            berkley
+            throw new IdentifierNotUnique("1120",
-            jones
+                "GUID is already in use by an existing object.");
+        }
-            jones
+        // Check if we are handling metadata or data
         boolean isScienceMetadata = isScienceMetadata(sysmeta);
             jones
-            jones
+        if (isScienceMetadata) {
-            jones
+            // CASE METADATA:
             try {
-            berkley
+                //System.out.println("CrudService: inserting document with guid " + guid.getValue());
-            berkley
+                this.insertDocument(object, guid, sessionData);
-            berkley
+                localId = im.getLocalId(guid.getValue());
-            jones
+            } catch (IOException e) {
                 String msg = "Could not create string from XML stream: " +
                     " " + e.getMessage();
                 logMetacat.debug(msg);
-            berkley
+                throw new ServiceFailure("1190", msg);
-            berkley
+            } catch(Exception e) {
                 String msg = "Unexpected error in CrudService.create: " + e.getMessage();
                 logMetacat.debug(msg);
                 throw new ServiceFailure("1190", msg);
             jones
             berkley
             jones
-            jones
+        } else {
-            jones
+            // DEFAULT CASE: DATA (needs to be checked and completed)
-            berkley
+            localId = insertDataObject(object, guid, sessionData);
             jones
+        }
             jones
-            jones
+        // For Metadata and Data, insert the system metadata into the object store too
-            berkley
+        String sysMetaLocalId = insertSystemMetadata(sysmeta, sessionData);
         //get the document info.  add any access params for the sysmeta too
-            berkley
+        //System.out.println("looking for access records to add for system " +
         //    "metadata who's parent doc's  local id is " + localId);
-            berkley
+        try
+        {
-            berkley
+            Hashtable<String, Object> h = im.getDocumentInfo(localId.substring(0, localId.lastIndexOf(".")));
-            berkley
+            Vector v = (Vector)h.get("access");
             for(int i=0; i<v.size(); i++)
+            {
-            jones
+                @SuppressWarnings("unchecked")
                 Hashtable<String, String> ah = (Hashtable<String, String>)v.elementAt(i);
-            berkley
+                String principal = (String)ah.get("principal_name");
                 String permission = (String)ah.get("permission");
                 String permissionType = (String)ah.get("permission_type");
                 String permissionOrder = (String)ah.get("permission_order");
-            berkley
+                int perm = new Integer(permission).intValue();
-            berkley
+                //System.out.println("found access record for principal " + principal);
                 //System.out.println("permission: " + perm + " perm_type: " + permissionType +
                 //    " perm_order: " + permissionOrder);
-            berkley
+                this.setAccess(token, guid, principal, perm, permissionType, permissionOrder, true);
             berkley
+        }
         catch(Exception e)
+        {
             logMetacat.error("Error setting permissions on System Metadata object " +
                     " with id " + sysMetaLocalId + ": " + e.getMessage());
-            berkley
+            //TODO: decide if this error should cancel the entire create or
             //if it should continue with just a logged error.
             berkley
-            jones
+        logMetacat.debug("Returning from CrudService.create()");
-            berkley
+        EventLog.getInstance().log(metacatUrl,
-            berkley
+                username, localId, "create");
-            berkley
+        logCrud.info("create D1GUID:" + guid.getValue() + ":D1SCIMETADATA:" + localId +
-            berkley
+                ":D1SYSMETADATA:"+ sysMetaLocalId + ":");
-            jones
+        return guid;
             jones
             berkley
     /**
      * update an existing object with a new object.  Change the system metadata
      * to reflect the changes and update it as well.
      */
     public Identifier update(AuthToken token, Identifier guid,
             InputStream object, Identifier obsoletedGuid, SystemMetadata sysmeta)
             throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique,
             UnsupportedType, InsufficientResources, NotFound, InvalidSystemMetadata,
             NotImplemented {
         try
+        {
             SessionData sessionData = getSessionData(token);
             //find the old systemmetadata (sm.old) document id (the one linked to obsoletedGuid)
             SystemMetadata sm = getSystemMetadata(token, obsoletedGuid);
             //change sm.old's obsoletedBy field
-            jones
+            List<Identifier> l = sm.getObsoletedByList();
-            berkley
+            l.add(guid);
             sm.setObsoletedByList(l);
             //update sm.old
             updateSystemMetadata(sm, sessionData);
             //change the obsoletes field of the new systemMetadata (sm.new) to point to the id of the old one
             sysmeta.addObsolete(obsoletedGuid);
             //insert sm.new
-            berkley
+            String sysMetaLocalId = insertSystemMetadata(sysmeta, sessionData);
             String localId;
             berkley
             boolean isScienceMetadata = isScienceMetadata(sysmeta);
             if(isScienceMetadata)
+            {
                 //update the doc
-            berkley
+                localId = updateDocument(object, obsoletedGuid, guid, sessionData, false);
             berkley
             else
+            {
                 //update a data file, not xml
-            berkley
+                localId = insertDataObject(object, guid, sessionData);
             berkley
             berkley
             IdentifierManager im = IdentifierManager.getInstance();
-            berkley
+            String username = "public";
             if(sessionData != null)
+            {
                 username = sessionData.getUserName();
+            }
-            berkley
+            EventLog.getInstance().log(metacatUrl,
-            berkley
+                    username, im.getLocalId(guid.getValue()), "update");
-            berkley
+            logCrud.info("update D1GUID:" + guid.getValue() + ":D1SCIMETADATA:" + localId +
-            berkley
+                    ":D1SYSMETADATA:"+ sysMetaLocalId + ":");
-            berkley
+            return guid;
+        }
         catch(Exception e)
+        {
-            berkley
+            throw new ServiceFailure("1310", "Error updating document in CrudService: " + e.getMessage());
             berkley
+    }
             berkley
     /**
-            berkley
+     * set access permissions on both the science metadata and system metadata
      */
     public void setAccess(AuthToken token, Identifier id, String principal, String permission,
             String permissionType, String permissionOrder)
       throws ServiceFailure
+    {
         setAccess(token, id, principal, permission, permissionType, permissionOrder, true);
+    }
     /**
-            berkley
+     * set access control on the doc
      * @param token
      * @param id
      * @param principal
      * @param permission
      */
     public void setAccess(AuthToken token, Identifier id, String principal, int permission,
       String permissionType, String permissionOrder, boolean setSystemMetadata)
       throws ServiceFailure
+    {
         String perm = "";
-            berkley
+        if(permission >= 4)
             berkley
             perm = "read";
+        }
-            berkley
+        if(permission >= 6)
             berkley
             perm = "write";
+        }
-            berkley
+        //System.out.println("perm in setAccess: " + perm);
         //System.out.println("permission in setAccess: " + permission);
-            berkley
+        setAccess(token, id, principal, perm, permissionType, permissionOrder,
                 setSystemMetadata);
+    }
     /**
-            berkley
+     * set the permission on the document
      * @param token
      * @param principal
      * @param permission
      * @param permissionType
      * @param permissionOrder
      * @return
      */
     public void setAccess(AuthToken token, Identifier id, String principal, String permission,
-            berkley
+            String permissionType, String permissionOrder, boolean setSystemMetadata)
-            berkley
+      throws ServiceFailure
+    {
-            berkley
+        /* TODO:
          * This is also not part of the D1 Crud spec.  This method is needed for
          * systems such as metacat where access to objects is controlled by
          * and ACL.  Higher level decisions need to be made about how this
          * should work within D1.
          */
-            berkley
+        try
+        {
-            berkley
+            final SessionData sessionData = getSessionData(token);
             if(sessionData == null)
+            {
                 throw new ServiceFailure("1000", "User must be logged in to set access.");
+            }
-            berkley
+            IdentifierManager im = IdentifierManager.getInstance();
             String docid = im.getLocalId(id.getValue());
             berkley
-            berkley
+            String permNum = "0";
-            berkley
+            if(permission.equals("read"))
             berkley
                 permNum = "4";
+            }
-            berkley
+            else if(permission.equals("write"))
             berkley
                 permNum = "6";
+            }
-            berkley
+            System.out.println("user " + sessionData.getUserName() +
                     " is setting access level " + permNum + " for permission " +
                     permissionType + " on doc with localid " + docid);
-            berkley
+            handler.setAccess(metacatUrl, sessionData.getUserName(), docid,
                     principal, permNum, permissionType, permissionOrder);
-            berkley
+            if(setSystemMetadata)
+            {
                 //set the same perms on the system metadata doc
                 String smlocalid = im.getSystemMetadataLocalId(id.getValue());
                 System.out.println("setting access on SM doc with localid " + smlocalid);
                 //cs.setAccess(token, smid, principal, permission, permissionType, permissionOrder);
                 handler.setAccess(metacatUrl, sessionData.getUserName(), smlocalid,
                         principal, permNum, permissionType, permissionOrder);
+            }
-            berkley
+            String username = "public";
             if(sessionData != null)
+            {
                 username = sessionData.getUserName();
+            }
-            berkley
+            EventLog.getInstance().log(metacatUrl,
-            berkley
+                    username, im.getLocalId(id.getValue()), "setAccess");
-            berkley
+            logCrud.info("setAccess");
             berkley
         catch(Exception e)
+        {
-            berkley
+            e.printStackTrace();
-            berkley
+            throw new ServiceFailure("1000", "Could not set access on the document with id " + id.getValue());
+        }
+    }
     /**
-            berkley
+     *  Retrieve the list of objects present on the MN that match the calling
      *  parameters. This method is required to support the process of Member
      *  Node synchronization. At a minimum, this method should be able to
      *  return a list of objects that match:
      *  startTime <= SystemMetadata.dateSysMetadataModified
      *  but is expected to also support date range (by also specifying endTime),
      *  and should also support slicing of the matching set of records by
      *  indicating the starting index of the response (where 0 is the index
      *  of the first item) and the count of elements to be returned.
+     *
-            berkley
+     *  If startTime or endTime is null, the query is not restricted by that parameter.
+     *
-            berkley
+     * @see http://mule1.dataone.org/ArchitectureDocs/mn_api_replication.html#MN_replication.listObjects
      * @param token
      * @param startTime
      * @param endTime
      * @param objectFormat
      * @param replicaStatus
      * @param start
      * @param count
      * @return ObjectList
      * @throws NotAuthorized
      * @throws InvalidRequest
      * @throws NotImplemented
      * @throws ServiceFailure
      * @throws InvalidToken
      */
     public ObjectList listObjects(AuthToken token, Date startTime, Date endTime,
         ObjectFormat objectFormat, boolean replicaStatus, int start, int count)
       throws NotAuthorized, InvalidRequest, NotImplemented, ServiceFailure, InvalidToken
+    {
-            berkley
+      //ObjectList ol = new ObjectList();
       //final SessionData sessionData = getSessionData(token);
       //int totalAfterQuery = 0;
             berkley
-            berkley
+      return IdentifierManager.getInstance().querySystemMetadata(startTime, endTime,
               objectFormat, replicaStatus, start, count);
       /////////////////////////////////////////////////////////////////////////
       ///////////////// OLD CODE //////////////////////////////////////////////
       /////////////////////////////////////////////////////////////////////////
 //      try
 //      {
 //          if (PropertyService.getProperty("database.queryCacheOn").equals("true"))
 //          {
 //              //System.out.println("the string stored into cache is "+ resultsetBuffer.toString());
 //              DBQuery.clearQueryResultCache();
 //          }
 //      }
 //      catch (PropertyNotFoundException e1)
 //      {
 //          //just don't do anything
 //      }
 //
 //      try
 //      {
 //          //TODO: Milliseconds need to be added to the dateFormat
 //          System.out.println("=========== Listing Objects =============");
 //          System.out.println("Current server time is: " + new Date());
 //          if(startTime != null)
 //          {
 //              System.out.println("query start time is " + startTime);
 //          }
 //          if(endTime != null)
 //          {
 //              System.out.println("query end time is " + endTime);
 //          }
 //          params.clear();
 //          params.put("qformat", new String[] {PropertyService.getProperty("crudService.listObjects.QFormat")});
 //          params.put("action", new String[] {"squery"});
 //          params.put("query", new String[] {createListObjectsPathQueryDocument()});
 //
 //          /*System.out.println("query is: metacatUrl: " + metacatUrl + " user: " + sessionData.getUserName() +
 //                  " sessionid: " + sessionData.getId() + " params: ");
 //          String url = metacatUrl + "/metacat?action=query&sessionid=" + sessionData.getId();
 //          Enumeration keys = params.keys();
 //          while(keys.hasMoreElements())
 //          {
 //              String key = (String)keys.nextElement();
 //              String[] parr = params.get(key);
 //              for(int i=0; i<parr.length; i++)
 //              {
 //                  System.out.println("param " + key + ": " + parr[i]);
 //                  url += "&" + key + "=" + parr[i] ;
 //              }
 //          }
 //          System.out.println("query url: " + url);
 //          */
 //          String username = "public";
 //          String[] groups = null;
 //          String sessionid = "";
 //          if(sessionData != null)
 //          {
 //              username = sessionData.getUserName();
 //              groups = sessionData.getGroupNames();
 //              sessionid = sessionData.getId();
 //          }
 //
 //          MetacatResultSet rs = handler.query(metacatUrl, params, username,
 //                  groups, sessionid);
 //          List docs = rs.getDocuments();
 //
 //          System.out.println("query returned " + docs.size() + " documents.");
 //          Vector<Document> docCopy = new Vector<Document>();
 //
 //          //preparse the list to remove any that don't match the query params
 //          /* TODO: this type of query/subquery processing is probably not scalable
 //           * to larger object stores.  This code should be revisited.  The metacat
 //           * query handler should probably be altered to handle the type of query
 //           * done here.
 //           */
 //          for(int i=0; i<docs.size(); i++)
 //          {
 //              Document d = (Document)docs.get(i);
 //
 //              ObjectFormat returnedObjectFormat = ObjectFormat.convert(d.getField("objectFormat"));
 //
 //              if(returnedObjectFormat != null &&
 //                 objectFormat != null &&
 //                 !objectFormat.toString().trim().equals(returnedObjectFormat.toString().trim()))
 //              { //make sure the objectFormat is the one specified
 //                  continue;
 //              }
 //
 //              String dateSMM = d.getField("dateSysMetadataModified");
 //              if((startTime != null || endTime != null) && dateSMM == null)
 //              {  //if startTime or endTime are not null, we need a date to compare to
 //                  continue;
 //              }
 //
 //              //date parse
 //              Date dateSysMetadataModified = null;
 //              if(dateSMM != null)
 //              {
 //
 //                  /*
 //                  if(dateSMM.indexOf(".") != -1)
 //                  {  //strip the milliseconds
 //                      //TODO: don't do this. we need milliseconds now.
 //                      //TODO: explore ISO 8601 to figure out milliseconds
 //                      dateSMM = dateSMM.substring(0, dateSMM.indexOf(".")) + 'Z';
 //                  }
 //                  */
 //                  //System.out.println("dateSMM: " + dateSMM);
 //                  //dateFormat.setTimeZone(TimeZone.getTimeZone("GMT-0"));
 //                  try
 //                  {   //the format we want
 //                      dateSysMetadataModified = dateFormat.parse(dateSMM);
 //                  }
 //                  catch(java.text.ParseException pe)
 //                  {   //try another legacy format
 //                      try
 //                      {
 //                          DateFormat dateFormat2 = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss.S'Z'");
 //                          dateFormat2.setTimeZone(TimeZone.getTimeZone("GMT-0"));
 //                          dateSysMetadataModified = dateFormat2.parse(dateSMM);
 //                      }
 //                      catch(java.text.ParseException pe2)
 //                      {
 //                          //try another legacy format
 //                          DateFormat dateFormat3 = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss'Z'");
 //                          dateFormat3.setTimeZone(TimeZone.getTimeZone("GMT-0"));
 //                          dateSysMetadataModified = dateFormat3.parse(dateSMM);
 //                      }
 //
 //                  }
 //              }
 //
 //              /*System.out.println("====================================");
 //              System.out.println("doc number " + i);
 //              System.out.println("docid: " + d.docid);
 //              System.out.println("guid: " + d.getField("identifier").trim());
 //              System.out.println("dateSMM: " + dateSMM);
 //              System.out.println("dateSysMetadataModified: " + dateSysMetadataModified);
 //              System.out.println("startTime: " + startTime);
 //              System.out.println("endtime: " + endTime);*/
 //
 //              int startDateComparison = 0;
 //              int endDateComparison = 0;
 //              if(startTime != null)
 //              {
 //                  Calendar zTime = Calendar.getInstance(TimeZone.getTimeZone("GMT-0"));
 //                  zTime.setTime(startTime);
 //                  startTime = zTime.getTime();
 //
 //                  if(dateSysMetadataModified == null)
 //                  {
 //                      startDateComparison = -1;
 //                  }
 //                  else
 //                  {
 //                      startDateComparison = dateSysMetadataModified.compareTo(startTime);
 //                  }
 //                  //System.out.println("startDateCom: " + startDateComparison);
 //              }
 //              else
 //              {
 //                  startDateComparison = 1;
 //              }
 //
 //              if(endTime != null)
 //              {
 //                  Calendar zTime = Calendar.getInstance(TimeZone.getTimeZone("GMT-0"));
 //                  zTime.setTime(endTime);
 //                  endTime = zTime.getTime();
 //
 //                  if(dateSysMetadataModified == null)
 //                  {
 //                      endDateComparison = 1;
 //                  }
 //                  else
 //                  {
 //                      endDateComparison = dateSysMetadataModified.compareTo(endTime);
 //                  }
 //                  //System.out.println("endDateCom: " + endDateComparison);
 //              }
 //              else
 //              {
 //                  endDateComparison = -1;
 //              }
 //
 //
 //              if(startDateComparison < 0 || endDateComparison > 0)
 //              {
 //                  continue;
 //              }
 //
 //              docCopy.add((Document)docs.get(i));
 //          } //end pre-parse
 //
 //          docs = docCopy;
 //          totalAfterQuery = docs.size();
 //          //System.out.println("total after subquery: " + totalAfterQuery);
 //
 //          //make sure we don't run over the end
 //          int end = start + count;
 //          if(end > docs.size())
 //          {
 //              end = docs.size();
 //          }
 //
 //          for(int i=start; i<end; i++)
 //          {
 //              //get the document from the result
 //              Document d = (Document)docs.get(i);
 //              //System.out.println("processing doc " + d.docid);
 //
 //              String dateSMM = d.getField("dateSysMetadataModified");
 //              //System.out.println("dateSMM: " + dateSMM);
 //              //System.out.println("parsed date: " + parseDate(dateSMM));
 //              Date dateSysMetadataModified = null;
 //              if(dateSMM != null)
 //              {
 //                  try
 //                  {
 //                      dateSysMetadataModified = parseDate(dateSMM);
 //                  }
 //                  catch(Exception e)
 //                  { //if we fail to parse the date, just ignore the value
 //                      dateSysMetadataModified = null;
 //                  }
 //              }
 //              ObjectFormat returnedObjectFormat = ObjectFormat.convert(d.getField("objectFormat"));
 //
 //
 //              ObjectInfo info = new ObjectInfo();
 //              //add the fields to the info object
 //              Checksum cs = new Checksum();
 //              cs.setValue(d.getField("checksum"));
 //              String csalg = d.getField("algorithm");
 //              if(csalg == null)
 //              {
 //                  csalg = "MD5";
 //              }
 //              ChecksumAlgorithm ca = ChecksumAlgorithm.convert(csalg);
 //              cs.setAlgorithm(ca);
 //              info.setChecksum(cs);
 //              info.setDateSysMetadataModified(dateSysMetadataModified);
 //              Identifier id = new Identifier();
 //              id.setValue(d.getField("identifier").trim());
 //              info.setIdentifier(id);
 //              info.setObjectFormat(returnedObjectFormat);
 //              String size = d.getField("size");
 //              if(size != null)
 //              {
 //                  info.setSize(new Long(size.trim()).longValue());
 //              }
 //              //add the ObjectInfo to the ObjectList
 //              //logCrud.info("objectFormat: " + info.getObjectFormat().toString());
 //              //logCrud.info("id: " + info.getIdentifier().getValue());
 //
 //              if(info.getIdentifier().getValue() != null)
 //              { //id can be null from tests.  should not happen in production.
 //                  if((info.getObjectFormat() != null && !info.getObjectFormat().toString().trim().equals("")))
 //                  { //objectFormat needs to not be null and not be an empty string
 //                    ol.addObjectInfo(info);
 //                  }
 //                  else
 //                  {
 //                      logCrud.info("Not adding object with null objectFormat" + info.getIdentifier().getValue().toString());
 //                  }
 //              }
 //
 //          }
 //      }
 //      catch(Exception e)
 //      {
 //          e.printStackTrace();
 //          logCrud.error("Error creating ObjectList: " + e.getMessage() + " cause: " + e.getCause());
 //          throw new ServiceFailure("1580", "Error retrieving ObjectList: " + e.getMessage());
 //      }
 //      String username = "public";
 //      if(sessionData != null)
 //      {
 //          username = sessionData.getUserName();
 //      }
 //      EventLog.getInstance().log(metacatUrl,
 //              username, null, "read");
 //      logCrud.info("listObjects");
 //      if(totalAfterQuery < count)
 //      {
 //          count = totalAfterQuery;
 //      }
 //      ol.setCount(count);
 //      ol.setStart(start);
 //      ol.setTotal(totalAfterQuery);
 //      return ol;
             berkley
     /**
      * Call listObjects with the default values for replicaStatus (true), start (0),
      * and count (1000).
      * @param token
      * @param startTime
      * @param endTime
      * @param objectFormat
      * @return
      * @throws NotAuthorized
      * @throws InvalidRequest
      * @throws NotImplemented
      * @throws ServiceFailure
      * @throws InvalidToken
      */
     public ObjectList listObjects(AuthToken token, Date startTime, Date endTime,
         ObjectFormat objectFormat)
       throws NotAuthorized, InvalidRequest, NotImplemented, ServiceFailure, InvalidToken
+    {
        return listObjects(token, startTime, endTime, objectFormat, true, 0, 1000);
+    }
             jones
-            berkley
+    /**
-            berkley
+     * Delete a document.
-            berkley
+     */
-            jones
+    public Identifier delete(AuthToken token, Identifier guid)
-            jones
+            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
-            berkley
+            NotImplemented, InvalidRequest {
-            berkley
+        logCrud.info("delete");
             berkley
         if(token == null || token.getToken().equals("publid"))
+        {
             throw new NotAuthorized("1320", "You must be logged in to delete records.");
+        }
         if(guid == null || guid.getValue().trim().equals(""))
+        {
             throw new InvalidRequest("1322", "No GUID specified in CrudService.delete()");
+        }
         final SessionData sessionData = getSessionData(token);
         IdentifierManager manager = IdentifierManager.getInstance();
         String docid;
         try
+        {
             docid = manager.getLocalId(guid.getValue());
+        }
         catch(McdbDocNotFoundException mnfe)
+        {
             throw new InvalidRequest("1322", "GUID " + guid + " not found.");
+        }
         try
+        {
             DocumentImpl.delete(docid, sessionData.getUserName(), sessionData.getGroupNames(), null);
+        }
         catch(Exception e)
+        {
             throw new ServiceFailure("1350", "Could not delete document: " + e.getMessage());
+        }
         return guid;
             jones
-            berkley
+    /**
-            berkley
+     * describe a document.
-            berkley
+     */
-            jones
+    public DescribeResponse describe(AuthToken token, Identifier guid)
-            jones
+            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
-            berkley
+            NotImplemented, InvalidRequest {
-            berkley
+        logCrud.info("describe");
             berkley
         if(token == null)
+        {
             throw new InvalidToken("1370", "Authentication token is null");
+        }
         if(guid == null || guid.getValue().trim().equals(""))
+        {
             throw new InvalidRequest("1362", "Guid is null.  A valid guid is required.");
+        }
         SystemMetadata sm = getSystemMetadata(token, guid);
         DescribeResponse dr = new DescribeResponse(sm.getObjectFormat(),
                 sm.getSize(), sm.getDateSysMetadataModified(), sm.getChecksum());
         return dr;
             jones
-            berkley
+    /**
      * get a document with a specified guid.
      */
-            jones
+    public InputStream get(AuthToken token, Identifier guid)
-            jones
+            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
             NotImplemented {
         // Retrieve the session information from the AuthToken
         // If the session is expired, then the user is 'public'
-            berkley
+        if(token == null)
+        {
             token = new AuthToken("Public");
+        }
-            jones
+        final SessionData sessionData = getSessionData(token);
         // Look up the localId for this global identifier
         IdentifierManager im = IdentifierManager.getInstance();
             berkley
-            berkley
+        try
+        {
-            jones
+            final String localId = im.getLocalId(guid.getValue());
-            berkley
+            InputStream objectStream;
-            berkley
+            try
+            {
                 String username = "public";
                 String[] groups = new String[0];
                 if(sessionData != null)
+                {
                     username = sessionData.getUserName();
                     groups = sessionData.getGroupNames();
+                }
             jones
-            berkley
+                objectStream = readFromMetacat(localId, username, groups);
             berkley
             } catch (PropertyNotFoundException e) {
                 e.printStackTrace();
                 throw new ServiceFailure("1030", "Error getting property from metacat: " + e.getMessage());
             } catch (ClassNotFoundException e) {
                 e.printStackTrace();
                 throw new ServiceFailure("1030", "Class not found error when reading from metacat: " + e.getMessage());
             } catch (IOException e) {
                 e.printStackTrace();
                 throw new ServiceFailure("1030", "IOException while reading from metacat: " + e.getMessage());
             } catch (SQLException e) {
                 e.printStackTrace();
                 throw new ServiceFailure("1030", "SQLException while reading from metacat: " + e.getMessage());
             } catch (McdbException e) {
                 e.printStackTrace();
                 throw new ServiceFailure("1030", "Metacat DB exception while reading from metacat: " + e.getMessage());
             } catch (ParseLSIDException e) {
                 e.printStackTrace();
                 throw new NotFound("1020", "LSID parsing exception while reading from metacat: " + e.getMessage());
             } catch (InsufficientKarmaException e) {
                 e.printStackTrace();
                 throw new NotAuthorized("1000", "User not authorized for get(): " + e.getMessage());
+            }
-            berkley
+            String username = "public";
             if(sessionData != null)
+            {
                 username = sessionData.getUserName();
+            }
-            berkley
+            EventLog.getInstance().log(metacatUrl,
-            berkley
+                    username, im.getLocalId(guid.getValue()), "read");
-            berkley
+            logCrud.info("get D1GUID:" + guid.getValue() + ":D1SCIMETADATA:" + localId +
                     ":");
             berkley
-            jones
+            return objectStream;
             berkley
         catch (McdbDocNotFoundException e)
+        {
-            berkley
+            throw new NotFound("1020", e.getMessage());
             berkley
             jones
-            berkley
+    /**
-            berkley
+     * get the checksum for a document.  defaults to MD5.
-            berkley
+     */
-            jones
+    public Checksum getChecksum(AuthToken token, Identifier guid)
-            jones
+            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
-            berkley
+            InvalidRequest, NotImplemented
+    {
-            berkley
+        logCrud.info("getChecksum");
-            berkley
+        return getChecksum(token, guid, "MD5");
             jones
-            berkley
+    /**
-            berkley
+     * get the checksum for a document with the given algorithm
-            berkley
+     */
-            jones
+    public Checksum getChecksum(AuthToken token, Identifier guid,
-            jones
+            String checksumAlgorithm) throws InvalidToken, ServiceFailure,
-            berkley
+            NotAuthorized, NotFound, InvalidRequest, NotImplemented
+    {
-            berkley
+        logCrud.info("getChecksum");
-            berkley
+        SystemMetadata sm = getSystemMetadata(token, guid);
         Checksum cs = sm.getChecksum();
         if(cs.getAlgorithm().toString().equals(checksumAlgorithm))
             berkley
-            berkley
+            return cs;
             berkley
-            berkley
+        else
             berkley
-            berkley
+            if(checksumAlgorithm == null)
+            {
                 checksumAlgorithm = "MD5";
+            }
             InputStream docStream = get(token, guid);
             String checksum;
             try
+            {
                 checksum = checksum(docStream, checksumAlgorithm);
+            }
             catch(Exception e)
+            {
                 throw new ServiceFailure("1410", "Error getting checksum: " + e.getMessage());
+            }
             Checksum c = new Checksum();
             c.setAlgorithm(ChecksumAlgorithm.convert(checksumAlgorithm));
             c.setValue(checksum);
             return c;
             berkley
             jones
-            berkley
+    /**
-            berkley
+     * get log records.
-            berkley
+     */
-            berkley
+    public Log getLogRecords(AuthToken token, Date fromDate, Date toDate, Event event)
-            jones
+            throws InvalidToken, ServiceFailure, NotAuthorized, InvalidRequest,
-            berkley
+            NotImplemented
+    {
-            berkley
+        /*System.out.println("=================== Getting log records ===================");
-            berkley
+        System.out.println("Current server time is: " + new Date());
         if(fromDate != null)
+        {
           System.out.println("query start time is " + fromDate);
+        }
         if(toDate != null)
+        {
           System.out.println("query end time is " + toDate);
-            berkley
+        }*/
-            berkley
+        Log log = new Log();
         Vector<LogEntry> logs = new Vector<LogEntry>();
-            berkley
+        IdentifierManager im = IdentifierManager.getInstance();
         EventLog el = EventLog.getInstance();
-            berkley
+        if(fromDate == null)
+        {
-            berkley
+            //System.out.println("setting fromdate from null");
-            berkley
+            fromDate = new Date(1);
+        }
         if(toDate == null)
+        {
-            berkley
+            //System.out.println("setting todate from null");
-            berkley
+            toDate = new Date();
+        }
             berkley
-            berkley
+        //System.out.println("fromDate: " + fromDate);
         //System.out.println("toDate: " + toDate);
             berkley
-            berkley
+        String report = el.getReport(null, null, null, null,
                 new java.sql.Timestamp(fromDate.getTime()),
-            leinfelder
+                new java.sql.Timestamp(toDate.getTime()), false);
             berkley
-            berkley
+        //System.out.println("report: " + report);
-            berkley
+        String logEntry = "<logEntry>";
         String endLogEntry = "</logEntry>";
         int startIndex = 0;
         int foundIndex = report.indexOf(logEntry, startIndex);
         while(foundIndex != -1)
+        {
             //parse out each entry
             int endEntryIndex = report.indexOf(endLogEntry, foundIndex);
             String entry = report.substring(foundIndex, endEntryIndex);
             //System.out.println("entry: " + entry);
             startIndex = endEntryIndex + endLogEntry.length();
             foundIndex = report.indexOf(logEntry, startIndex);
             String entryId = getLogEntryField("entryid", entry);
             String ipAddress = getLogEntryField("ipAddress", entry);
             String principal = getLogEntryField("principal", entry);
             String docid = getLogEntryField("docid", entry);
-            berkley
+            String eventS = getLogEntryField("event", entry);
-            berkley
+            String dateLogged = getLogEntryField("dateLogged", entry);
-            berkley
+            LogEntry le = new LogEntry();
             berkley
-            berkley
+            Event e = Event.convert(eventS);
-            berkley
+            if(e == null)
             { //skip any events that are not Dataone Crud events
                 continue;
+            }
-            berkley
+            le.setEvent(e);
-            berkley
+            Identifier entryid = new Identifier();
             entryid.setValue(entryId);
-            berkley
+            le.setEntryId(entryid);
-            berkley
+            Identifier identifier = new Identifier();
             try
+            {
-            berkley
+                //System.out.println("converting docid '" + docid + "' to a guid.");
-            berkley
+                if(docid == null || docid.trim().equals("") || docid.trim().equals("null"))
+                {
                     continue;
+                }
-            berkley
+                docid = docid.substring(0, docid.lastIndexOf("."));
-            berkley
+                identifier.setValue(im.getGUID(docid, im.getLatestRevForLocalId(docid)));
+            }
             catch(Exception ex)
             { //try to get the guid, if that doesn't work, just use the local id
-            berkley
+                //throw new ServiceFailure("1030", "Error getting guid for localId " +
-            berkley
+                //        docid + ": " + ex.getMessage());\
                 //skip it if the guid can't be found
-            berkley
+                continue;
             berkley
-            berkley
+            le.setIdentifier(identifier);
             le.setIpAddress(ipAddress);
-            berkley
+            Calendar c = Calendar.getInstance();
             String year = dateLogged.substring(0, 4);
             String month = dateLogged.substring(5, 7);
             String date = dateLogged.substring(8, 10);
             //System.out.println("year: " + year + " month: " + month + " day: " + date);
             c.set(new Integer(year).intValue(), new Integer(month).intValue(), new Integer(date).intValue());
             Date logDate = c.getTime();
-            berkley
+            le.setDateLogged(logDate);
-            berkley
+            NodeReference memberNode = new NodeReference();
             memberNode.setValue(ipAddress);
-            berkley
+            le.setMemberNode(memberNode);
-            berkley
+            Principal princ = new Principal();
             princ.setValue(principal);
-            berkley
+            le.setPrincipal(princ);
             le.setUserAgent("metacat/RESTService");
             berkley
             if(event == null)
+            {
                 logs.add(le);
+            }
             if(event != null &&
                e.toString().toLowerCase().trim().equals(event.toString().toLowerCase().trim()))
+            {
               logs.add(le);
+            }
             berkley
-            berkley
+        log.setLogEntryList(logs);
-            berkley
+        logCrud.info("getLogRecords");
-            berkley
+        return log;
             jones
             berkley
     /**
      * parse a logEntry and get the relavent field from it
      * @param fieldname
      * @param entry
      * @return
      */
     private String getLogEntryField(String fieldname, String entry)
+    {
         String begin = "<" + fieldname + ">";
         String end = "</" + fieldname + ">";
         //System.out.println("looking for " + begin + " and " + end + " in entry " + entry);
         String s = entry.substring(entry.indexOf(begin) + begin.length(), entry.indexOf(end));
         //System.out.println("entry " + fieldname + " : " + s);
         return s;
+    }
             jones
-            berkley
+    /**
      * get the system metadata for a document with a specified guid.
      */
-            berkley
+public SystemMetadata getSystemMetadata(AuthToken token, Identifier guid)
-            jones
+            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
             InvalidRequest, NotImplemented {
             jones
-            jones
+        logMetacat.debug("CrudService.getSystemMetadata - for guid: " + guid.getValue());
         // Retrieve the session information from the AuthToken
         // If the session is expired, then the user is 'public'
         final SessionData sessionData = getSessionData(token);
         try {
             IdentifierManager im = IdentifierManager.getInstance();
-            berkley
+            final String localId = im.getSystemMetadataLocalId(guid.getValue());
-            berkley
+            InputStream objectStream;
             jones
-            berkley
+            try {
                 String username = "public";
                 String[] groupnames = null;
                 if(sessionData != null)
+                {
                     username = sessionData.getUserName();
                     groupnames = sessionData.getGroupNames();
+                }
             jones
-            berkley
+                objectStream = readFromMetacat(localId, username, groupnames);
             } catch (PropertyNotFoundException e) {
                 e.printStackTrace();
                 throw new ServiceFailure("1090", "Property not found while reading system metadata from metacat: " + e.getMessage());
             } catch (ClassNotFoundException e) {
                 e.printStackTrace();
                 throw new ServiceFailure("1090", "Class not found while reading system metadata from metacat: " + e.getMessage());
             } catch (IOException e) {
                 e.printStackTrace();
                 throw new ServiceFailure("1090", "IOException while reading system metadata from metacat: " + e.getMessage());
             } catch (SQLException e) {
                 e.printStackTrace();
                 throw new ServiceFailure("1090", "SQLException while reading system metadata from metacat: " + e.getMessage());
             } catch (McdbException e) {
                 e.printStackTrace();
                 throw new ServiceFailure("1090", "Metacat DB Exception while reading system metadata from metacat: " + e.getMessage());
             } catch (ParseLSIDException e) {
                 e.printStackTrace();
                 throw new NotFound("1060", "Error parsing LSID while reading system metadata from metacat: " + e.getMessage());
             } catch (InsufficientKarmaException e) {
                 e.printStackTrace();
                 throw new NotAuthorized("1040", "User not authorized for get() on system metadata: " + e.getMessage());
+            }
             berkley
-            jones
+            // Deserialize the xml to create a SystemMetadata object
             SystemMetadata sysmeta = deserializeSystemMetadata(objectStream);
-            berkley
+            String username = "public";
             if(sessionData != null)
+            {
                 username = sessionData.getUserName();
+            }
-            berkley
+            EventLog.getInstance().log(metacatUrl,
-            berkley
+                    username, im.getLocalId(guid.getValue()), "read");
-            berkley
+            logCrud.info("getsystemmetadata D1GUID:" + guid.getValue()  +
-            berkley
+                    ":D1SYSMETADATA:"+ localId + ":");
-            jones
+            return sysmeta;
         } catch (McdbDocNotFoundException e) {
-            berkley
+            //e.printStackTrace();
-            berkley
+            throw new NotFound("1040", e.getMessage());
             jones
             jones
             berkley
     /**
      * parse the date in the systemMetadata
      * @param s
      * @return
      * @throws Exception
      */
-            berkley
+    public Date parseDate(String s)
-            berkley
+      throws Exception
+    {
-            berkley
+        /* TODO:
          * This method should be replaced by a DateFormatter
          */
-            berkley
+        Date d = null;
         int tIndex = s.indexOf("T");
         int zIndex = s.indexOf("Z");
         if(tIndex != -1 && zIndex != -1)
         { //parse a date that looks like 2010-05-18T21:12:54.362Z
             //System.out.println("original date: " + s);
             String date = s.substring(0, tIndex);
             String year = date.substring(0, date.indexOf("-"));
             String month = date.substring(date.indexOf("-") + 1, date.lastIndexOf("-"));
             String day = date.substring(date.lastIndexOf("-") + 1, date.length());
             /*System.out.println("date: " + "year: " + new Integer(year).intValue() +
                     " month: " + new Integer(month).intValue() + " day: " +
                     new Integer(day).intValue());
             */
             String time = s.substring(tIndex + 1, zIndex);
             String hour = time.substring(0, time.indexOf(":"));
             String minute = time.substring(time.indexOf(":") + 1, time.lastIndexOf(":"));
             String seconds = "00";
             String milliseconds = "00";
             if(time.indexOf(".") != -1)
+            {
                 seconds = time.substring(time.lastIndexOf(":") + 1, time.indexOf("."));
                 milliseconds = time.substring(time.indexOf(".") + 1, time.length());
+            }
-            berkley
+            else
+            {
                 seconds = time.substring(time.lastIndexOf(":") + 1, time.length());
+            }
-            berkley
+            /*System.out.println("time: " + "hour: " + new Integer(hour).intValue() +
                     " minute: " + new Integer(minute).intValue() + " seconds: " +
                     new Integer(seconds).intValue() + " milli: " +
                     new Integer(milliseconds).intValue());*/
             //d = DateFormat.getDateTimeInstance().parse(date + " " + time);
-            berkley
+            Calendar c = Calendar.getInstance(TimeZone.getTimeZone("GMT-0")/*TimeZone.getDefault()*/);
-            berkley
+            c.set(new Integer(year).intValue(), new Integer(month).intValue() - 1,
                   new Integer(day).intValue(), new Integer(hour).intValue(),
                   new Integer(minute).intValue(), new Integer(seconds).intValue());
             c.set(Calendar.MILLISECOND, new Integer(milliseconds).intValue());
             d = new Date(c.getTimeInMillis());
             //System.out.println("d: " + d);
             return d;
+        }
         else
         {  //if it's not in the expected format, try the formatter
             return DateFormat.getDateTimeInstance().parse(s);
+        }
+    }
             jones
-            jones
+    /*
      * Look up the information on the session using the token provided in
      * the AuthToken.  The Session should have all relevant user information.
      * If the session has expired or is invalid, the 'public' session will
      * be returned, giving the user anonymous access.
      */
-            berkley
+    public static SessionData getSessionData(AuthToken token) {
-            jones
+        SessionData sessionData = null;
         String sessionId = "PUBLIC";
         if (token != null) {
             sessionId = token.getToken();
+        }
         // if the session id is registered in SessionService, get the
         // SessionData for it. Otherwise, use the public session.
-            berkley
+        //System.out.println("sessionid: " + sessionId);
-            berkley
+        if (sessionId != null &&
-            berkley
+            !sessionId.toLowerCase().equals("public") &&
-            berkley
+            SessionService.getInstance().isSessionRegistered(sessionId))
+        {
-            berkley
+            sessionData = SessionService.getInstance().getRegisteredSession(sessionId);
-            jones
+        } else {
-            berkley
+            sessionData = SessionService.getInstance().getPublicSession();
             jones
             berkley
-            jones
+        return sessionData;
+    }
     /**
      * Determine if a given object should be treated as an XML science metadata
      * object.
+     *
      * TODO: This test should be externalized in a configuration dictionary rather than being hardcoded.
+     *
      * @param sysmeta the SystemMetadata describig the object
      * @return true if the object should be treated as science metadata
      */
     private boolean isScienceMetadata(SystemMetadata sysmeta) {
-            berkley
+        /*boolean scimeta = false;
-            berkley
+        //TODO: this should be read from a .properties file instead of being hard coded
-            jones
+        switch (sysmeta.getObjectFormat()) {
             case EML_2_1_0: scimeta = true; break;
             case EML_2_0_1: scimeta = true; break;
             case EML_2_0_0: scimeta = true; break;
             case FGDC_STD_001_1_1999: scimeta = true; break;
             case FGDC_STD_001_1998: scimeta = true; break;
             case NCML_2_2: scimeta = true; break;
-            berkley
+            case DSPACE_METS_SIP_1_0: scimeta = true; break;
             jones
-            berkley
+        return scimeta;*/
         return MetadataTypeRegister.isMetadataType(sysmeta.getObjectFormat());
             jones
-            berkley
+    /**
      * insert a data doc
      * @param object
      * @param guid
      * @param sessionData
      * @throws ServiceFailure
-            berkley
+     * @returns localId of the data object inserted
-            berkley
+     */
-            berkley
+    private String insertDataObject(InputStream object, Identifier guid,
-            jones
+            SessionData sessionData) throws ServiceFailure {
-            berkley
+        String username = "public";
         String[] groups = null;
         if(sessionData != null)
+        {
           username = sessionData.getUserName();
           groups = sessionData.getGroupNames();
+        }
             jones
         // generate guid/localId pair for object
         logMetacat.debug("Generating a guid/localId mapping");
         IdentifierManager im = IdentifierManager.getInstance();
         String localId = im.generateLocalId(guid.getValue(), 1);
         try {
             logMetacat.debug("Case DATA: starting to write to disk.");
             if (DocumentImpl.getDataFileLockGrant(localId)) {
                 // Save the data file to disk using "localId" as the name
                 try {
                     String datafilepath = PropertyService.getProperty("application.datafilepath");
                     File dataDirectory = new File(datafilepath);
                     dataDirectory.mkdirs();
                     File newFile = writeStreamToFile(dataDirectory, localId, object);
                     // TODO: Check that the file size matches SystemMetadata
                     //                        long size = newFile.length();
                     //                        if (size == 0) {
                     //                            throw new IOException("Uploaded file is 0 bytes!");
                     //                        }
                     // Register the file in the database (which generates an exception
                     // if the localId is not acceptable or other untoward things happen
                     try {
                         logMetacat.debug("Registering document...");
                         DocumentImpl.registerDocument(localId, "BIN", localId,
                                 username, groups);
                         logMetacat.debug("Registration step completed.");
                     } catch (SQLException e) {
                         //newFile.delete();
                         logMetacat.debug("SQLE: " + e.getMessage());
                         e.printStackTrace(System.out);
-            berkley
+                        throw new ServiceFailure("1190", "Registration failed: " + e.getMessage());
-            jones
+                    } catch (AccessionNumberException e) {
                         //newFile.delete();
                         logMetacat.debug("ANE: " + e.getMessage());
                         e.printStackTrace(System.out);
-            berkley
+                        throw new ServiceFailure("1190", "Registration failed: " + e.getMessage());
-            jones
+                    } catch (Exception e) {
                         //newFile.delete();
                         logMetacat.debug("Exception: " + e.getMessage());
                         e.printStackTrace(System.out);
-            berkley
+                        throw new ServiceFailure("1190", "Registration failed: " + e.getMessage());
             jones
                     logMetacat.debug("Logging the creation event.");
-            berkley
+                    EventLog.getInstance().log(metacatUrl,
-            berkley
+                            username, localId, "create");
             jones
                     // Schedule replication for this data file
                     logMetacat.debug("Scheduling replication.");
                     ForceReplicationHandler frh = new ForceReplicationHandler(
-            berkley
+                            localId, "create", false, null);
             jones
                 } catch (PropertyNotFoundException e) {
-            berkley
+                    throw new ServiceFailure("1190", "Could not lock file for writing:" + e.getMessage());
             jones
+            }
-            berkley
+            return localId;
-            jones
+        } catch (Exception e) {
             // Could not get a lock on the document, so we can not update the file now
-            berkley
+            throw new ServiceFailure("1190", "Failed to lock file: " + e.getMessage());
             jones
+    }
-            berkley
+    /**
      * write a file to a stream
      * @param dir
      * @param fileName
      * @param data
      * @return
      * @throws ServiceFailure
      */
-            jones
+    private File writeStreamToFile(File dir, String fileName, InputStream data)
         throws ServiceFailure {
         File newFile = new File(dir, fileName);
         logMetacat.debug("Filename for write is: " + newFile.getAbsolutePath());
         try {
             if (newFile.createNewFile()) {
                 // write data stream to desired file
                 OutputStream os = new FileOutputStream(newFile);
                 long length = IOUtils.copyLarge(data, os);
                 os.flush();
                 os.close();
             } else {
                 logMetacat.debug("File creation failed, or file already exists.");
-            berkley
+                throw new ServiceFailure("1190", "File already exists: " + fileName);
             jones
         } catch (FileNotFoundException e) {
             logMetacat.debug("FNF: " + e.getMessage());
-            berkley
+            throw new ServiceFailure("1190", "File not found: " + fileName + " "
-            jones
+                    + e.getMessage());
         } catch (IOException e) {
             logMetacat.debug("IOE: " + e.getMessage());
-            berkley
+            throw new ServiceFailure("1190", "File was not written: " + fileName
-            jones
+                    + " " + e.getMessage());
+        }
         return newFile;
             jones
-            berkley
+    /**
-            berkley
+     * insert a systemMetadata doc, return the localId of the sysmeta
-            berkley
+     */
-            berkley
+    private String insertSystemMetadata(SystemMetadata sysmeta, SessionData sessionData)
-            berkley
+        throws ServiceFailure
+    {
-            jones
+        logMetacat.debug("Starting to insert SystemMetadata...");
         // generate guid/localId pair for sysmeta
-            jones
+        Identifier sysMetaGuid = new Identifier();
         sysMetaGuid.setValue(DocumentUtil.generateDocumentId(1));
-            jones
+        sysmeta.setDateSysMetadataModified(new Date());
-            berkley
+        System.out.println("****inserting new system metadata with modified date " +
                 sysmeta.getDateSysMetadataModified());
             jones
         String xml = new String(serializeSystemMetadata(sysmeta).toByteArray());
-            berkley
+        System.out.println("sysmeta: " + xml);
-            berkley
+        String localId = insertDocument(xml, sysMetaGuid, sessionData, true);
-            berkley
+        System.out.println("sysmeta inserted with localId " + localId);
-            berkley
+        //insert the system metadata doc id into the systemmetadata table to
-            berkley
+        //link it to the data or metadata document
-            berkley
+        IdentifierManager.getInstance().createSystemMetadataMapping(
-            berkley
+                sysmeta, sysMetaGuid.getValue());
-            berkley
+        return localId;
             jones
-            berkley
+    /**
-            berkley
+     * update a systemMetadata doc
      */
     private void updateSystemMetadata(SystemMetadata sm, SessionData sessionData)
       throws ServiceFailure
+    {
         try
+        {
-            berkley
+            String smId = IdentifierManager.getInstance().getSystemMetadataLocalId(sm.getIdentifier().getValue());
-            berkley
+            System.out.println("setting date modified to " + new Date());
-            berkley
+            sm.setDateSysMetadataModified(new Date());
             String xml = new String(serializeSystemMetadata(sm).toByteArray());
-            berkley
+            String localId = updateDocument(xml, sm.getIdentifier(), null, sessionData, true);
-            berkley
+            IdentifierManager.getInstance().updateSystemMetadataMapping(sm.getIdentifier().getValue(), localId);
+        }
         catch(Exception e)
+        {
-            berkley
+            throw new ServiceFailure("1030", "Error updating system metadata: " + e.getMessage());
             berkley
+    }
-            berkley
+    private String insertDocument(String xml, Identifier guid, SessionData sessionData)
         throws ServiceFailure
+    {
         return insertDocument(xml, guid, sessionData, false);
+    }
-            berkley
+    /**
      * insert a document
      * NOTE: this method shouldn't be used from the update or create() methods.
      * we shouldn't be putting the science metadata or data objects into memory.
      */
-            berkley
+    private String insertDocument(String xml, Identifier guid, SessionData sessionData,
             boolean isSystemMetadata)
-            berkley
+        throws ServiceFailure
+    {
-            berkley
+        return insertOrUpdateDocument(xml, guid, sessionData, "insert", isSystemMetadata);
             berkley
     /**
      * insert a document from a stream
      */
     private String insertDocument(InputStream is, Identifier guid, SessionData sessionData)
       throws IOException, ServiceFailure
+    {
         //HACK: change this eventually.  we should not be converting the stream to a string
         String xml = IOUtils.toString(is);
         return insertDocument(xml, guid, sessionData);
+    }
     /**
      * update a document
      * NOTE: this method shouldn't be used from the update or create() methods.
      * we shouldn't be putting the science metadata or data objects into memory.
      */
-            berkley
+    private String updateDocument(String xml, Identifier obsoleteGuid,
             Identifier guid, SessionData sessionData, boolean isSystemMetadata)
-            berkley
+        throws ServiceFailure
+    {
-            berkley
+        return insertOrUpdateDocument(xml, obsoleteGuid, sessionData, "update", isSystemMetadata);
             berkley
     /**
      * update a document from a stream
      */
-            berkley
+    private String updateDocument(InputStream is, Identifier obsoleteGuid,
             Identifier guid, SessionData sessionData, boolean isSystemMetadata)
-            berkley
+      throws IOException, ServiceFailure
+    {
         //HACK: change this eventually.  we should not be converting the stream to a string
         String xml = IOUtils.toString(is);
-            berkley
+        String localId = updateDocument(xml, obsoleteGuid, guid, sessionData, isSystemMetadata);
-            berkley
+        IdentifierManager im = IdentifierManager.getInstance();
         if(guid != null)
+        {
           im.createMapping(guid.getValue(), localId);
+        }
         return localId;
+    }
     /**
-            berkley
+     * insert a document, return the id of the document that was inserted
      */
-            berkley
+    protected String insertOrUpdateDocument(String xml, Identifier guid,
             SessionData sessionData, String insertOrUpdate, boolean isSystemMetadata)
-            jones
+        throws ServiceFailure {
         logMetacat.debug("Starting to insert xml document...");
         IdentifierManager im = IdentifierManager.getInstance();
         // generate guid/localId pair for sysmeta
-            berkley
+        String localId = null;
         if(insertOrUpdate.equals("insert"))
+        {
-            berkley
+            localId = im.generateLocalId(guid.getValue(), 1, isSystemMetadata);
             berkley
         else
+        {
             //localid should already exist in the identifier table, so just find it
             try
+            {
-            berkley
+                System.out.println("updating guid " + guid.getValue());
                 if(!isSystemMetadata)
+                {
                     System.out.println("looking in identifier table for guid " + guid.getValue());
                     localId = im.getLocalId(guid.getValue());
+                }
                 else
+                {
                     System.out.println("looking in systemmetadata table for guid " + guid.getValue());
                     localId = im.getSystemMetadataLocalId(guid.getValue());
+                }
                 System.out.println("localId: " + localId);
-            berkley
+                //increment the revision
                 String docid = localId.substring(0, localId.lastIndexOf("."));
                 String revS = localId.substring(localId.lastIndexOf(".") + 1, localId.length());
                 int rev = new Integer(revS).intValue();
                 rev++;
                 docid = docid + "." + rev;
                 localId = docid;
-            berkley
+                System.out.println("incremented localId: " + localId);
             berkley
             catch(McdbDocNotFoundException e)
+            {
-            berkley
+                throw new ServiceFailure("1030", "CrudService.insertOrUpdateDocument(): " +
-            berkley
+                    "guid " + guid.getValue() + " should have been in the identifier table, but it wasn't: " + e.getMessage());
+            }
+        }
-            jones
+        logMetacat.debug("Metadata guid|localId: " + guid.getValue() + "|" +
-            jones
+                localId);
         String[] action = new String[1];
-            berkley
+        action[0] = insertOrUpdate;
-            jones
+        params.put("action", action);
         String[] docid = new String[1];
         docid[0] = localId;
         params.put("docid", docid);
         String[] doctext = new String[1];
         doctext[0] = xml;
         logMetacat.debug(doctext[0]);
         params.put("doctext", doctext);
             jones
         // TODO: refactor handleInsertOrUpdateAction() to not output XML directly
         // onto output stream, or alternatively, capture that and parse it to
         // generate the right exceptions
-            berkley
+        //ByteArrayOutputStream output = new ByteArrayOutputStream();
         //PrintWriter pw = new PrintWriter(output);
-            berkley
+        String username = "public";
         String[] groupnames = null;
         if(sessionData != null)
+        {
             username = sessionData.getUserName();
             groupnames = sessionData.getGroupNames();
+        }
-            berkley
+        String result = handler.handleInsertOrUpdateAction(metacatUrl, null,
-            berkley
+                            null, params, username, groupnames);
-            berkley
+        if(result.indexOf("<error>") != -1)
+        {
             throw new ServiceFailure("1000", "Error inserting or updating document: " + result);
+        }
-            berkley
+        //String outputS = new String(output.toByteArray());
         logMetacat.debug("CrudService.insertDocument - Metacat returned: " + result);
-            berkley
+        logMetacat.debug("Finsished inserting xml document with id " + localId);
         return localId;
             jones
-            berkley
+    /**
-            berkley
+     * serialize a dataone type
-            berkley
+     */
-            jones
+//    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);
 //    }
             berkley
     /**
-            berkley
+     * serialize a system metadata doc
      * @param sysmeta
      * @return
      * @throws ServiceFailure
      */
-            jones
+    public static ByteArrayOutputStream serializeSystemMetadata(SystemMetadata sysmeta)
-            jones
+        throws ServiceFailure {
         IBindingFactory bfact;
         ByteArrayOutputStream sysmetaOut = null;
         try {
             bfact = BindingDirectory.getFactory(SystemMetadata.class);
             IMarshallingContext mctx = bfact.createMarshallingContext();
             sysmetaOut = new ByteArrayOutputStream();
             mctx.marshalDocument(sysmeta, "UTF-8", null, sysmetaOut);
         } catch (JiBXException e) {
-            berkley
+            e.printStackTrace();
-            berkley
+            throw new ServiceFailure("1190", "Failed to serialize and insert SystemMetadata: " + e.getMessage());
             jones
         return sysmetaOut;
+    }
             jones
-            berkley
+    /**
      * deserialize a system metadata doc
      * @param xml
      * @return
      * @throws ServiceFailure
      */
-            jones
+    public static SystemMetadata deserializeSystemMetadata(InputStream xml)
         throws ServiceFailure {
         try {
             IBindingFactory bfact = BindingDirectory.getFactory(SystemMetadata.class);
             IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
             SystemMetadata sysmeta = (SystemMetadata) uctx.unmarshalDocument(xml, null);
             return sysmeta;
         } catch (JiBXException e) {
-            berkley
+            e.printStackTrace();
             throw new ServiceFailure("1190", "Failed to deserialize and insert SystemMetadata: " + e.getMessage());
             jones
+    }
             berkley
     /**
-            berkley
+     * read a document from metacat and return the InputStream
+     *
      * @param localId
      * @param username
      * @param groups
      * @return
      * @throws InsufficientKarmaException
      * @throws ParseLSIDException
      * @throws PropertyNotFoundException
      * @throws McdbException
      * @throws SQLException
      * @throws ClassNotFoundException
      * @throws IOException
      */
     private InputStream readFromMetacat(String localId, String username, String[] groups)
         throws InsufficientKarmaException, ParseLSIDException,
         PropertyNotFoundException, McdbException, SQLException,
         ClassNotFoundException, IOException
+    {
         File tmpDir;
         try
+        {
             tmpDir = new File(PropertyService.getProperty("application.tempDir"));
+        }
         catch(PropertyNotFoundException pnfe)
+        {
             logMetacat.error("ResourceHandler.writeMMPPartstoFiles: " +
                     "application.tmpDir not found.  Using /tmp instead.");
             tmpDir = new File("/tmp");
+        }
         Date d = new Date();
         final File outputFile = new File(tmpDir, "metacat.output." + d.getTime());
         FileOutputStream dataSink = new FileOutputStream(outputFile);
         handler.readFromMetacat(metacatUrl, null,
                 dataSink, localId, "xml",
                 username,
                 groups, true, params);
         //set a timer to clean up the temp files
         Timer t = new Timer();
         TimerTask tt = new TimerTask() {
             @Override
             public void run()
+            {
                 outputFile.delete();
+            }
         };
         t.schedule(tt, 20000); //schedule after 20 secs
         InputStream objectStream = new FileInputStream(outputFile);
         return objectStream;
+    }
     /**
-            berkley
+     * return an MD5 checksum for the stream
      * @param is
      * @return
-            jones
+     * @throws IOException
      * @throws NoSuchAlgorithmException
-            berkley
+     */
-            jones
+    public static String checksum(InputStream is) throws NoSuchAlgorithmException, IOException
             berkley
         return checksum(is, "MD5");
+    }
     /**
      * produce a checksum for item using the given algorithm
-            jones
+     * @throws IOException
      * @throws NoSuchAlgorithmException
-            berkley
+     */
-            jones
+    public static String checksum(InputStream is, String algorithm) throws NoSuchAlgorithmException, IOException
             berkley
-            berkley
+        return ServiceTypeUtil.checksum(is, ChecksumAlgorithm.convert(algorithm)).getValue();
             berkley
     /**
      * parse the metacat date which looks like 2010-06-08 (YYYY-MM-DD) into
      * a proper date object
      * @param date
      * @return
      */
     private Date parseMetacatDate(String date)
+    {
         String year = date.substring(0, 4);
         String month = date.substring(5, 7);
         String day = date.substring(8, 10);
-            berkley
+        Calendar c = Calendar.getInstance(TimeZone.getDefault());
-            berkley
+        c.set(new Integer(year).intValue(),
               new Integer(month).intValue(),
               new Integer(day).intValue());
-            berkley
+        System.out.println("time in parseMetacatDate: " + c.getTime());
-            berkley
+        return c.getTime();
+    }
     /**
      * find the size (in bytes) of a stream
      * @param is
      * @return
      * @throws IOException
      */
     private long sizeOfStream(InputStream is)
         throws IOException
+    {
         long size = 0;
         byte[] b = new byte[1024];
         int numread = is.read(b, 0, 1024);
         while(numread != -1)
+        {
             size += numread;
             numread = is.read(b, 0, 1024);
+        }
         return size;
+    }
             berkley
     /**
      * create system metadata with a specified id, doc and format
-            jones
+     * @throws McdbDocNotFoundException
      * @throws SQLException
      * @throws AccessionNumberException
      * @throws NumberFormatException
      * @throws IOException
      * @throws NoSuchAlgorithmException
      * @throws PropertyNotFoundException
-            berkley
+     */
-            jones
+    private SystemMetadata createSystemMetadata(String localId, AuthToken token)
         throws McdbDocNotFoundException, NumberFormatException, AccessionNumberException,
         SQLException, NoSuchAlgorithmException, IOException, PropertyNotFoundException, BaseException {
-            berkley
+        IdentifierManager im = IdentifierManager.getInstance();
-            berkley
+        Hashtable<String, Object> docInfo = im.getDocumentInfo(localId);
             jones
-            berkley
+        //get the document text
         int rev = im.getLatestRevForLocalId(localId);
         Identifier identifier = new Identifier();
-            jones
+        try {
-            berkley
+            identifier.setValue(im.getGUID(localId, rev));
-            jones
+        } catch (McdbDocNotFoundException mcdbe) {
             //we're creating a new SM doc for a doc that is not in the identifier table
             //so we need to add it to
-            berkley
+            System.out.println("No guid in the identifier table.  adding it for " + localId);
             im.createMapping(localId, localId);
             System.out.println("mapping created for " + localId);
             AccessionNumber accNum = new AccessionNumber(localId, "NONE");
             identifier.setValue(im.getGUID(accNum.getDocid(), rev));
+        }
             jones
-            berkley
+        System.out.println("creating system metadata for guid " + identifier.getValue());
-            berkley
+        InputStream is = this.get(token, identifier);
-            jones
+        SystemMetadata sm = new SystemMetadata();
             berkley
         //set the id
         sm.setIdentifier(identifier);
             jones
-            berkley
+        //set the object format
-            jones
+        String doctype = (String) docInfo.get("doctype");
         ObjectFormat format = ObjectFormat.convert((String) docInfo.get("doctype"));
         if (format == null) {
             if (doctype.trim().equals("BIN")) {
-            berkley
+                format = ObjectFormat.OCTET_STREAM;
-            jones
+            } else {
-            berkley
+                format = ObjectFormat.convert("text/plain");
+            }
+        }
         sm.setObjectFormat(format);
             jones
-            berkley
+        //create the checksum
         String checksumS = checksum(is);
         ChecksumAlgorithm ca = ChecksumAlgorithm.convert("MD5");
         Checksum checksum = new Checksum();
         checksum.setValue(checksumS);
         checksum.setAlgorithm(ca);
         sm.setChecksum(checksum);
             jones
-            berkley
+        //set the size
         is = this.get(token, identifier);
         sm.setSize(sizeOfStream(is));
             jones
-            berkley
+        //submitter
         Principal p = new Principal();
-            jones
+        p.setValue((String) docInfo.get("user_owner"));
-            berkley
+        sm.setSubmitter(p);
         sm.setRightsHolder(p);
-            jones
+        try {
             Date dateCreated = parseMetacatDate((String) docInfo.get("date_created"));
-            berkley
+            sm.setDateUploaded(dateCreated);
-            jones
+            Date dateUpdated = parseMetacatDate((String) docInfo.get("date_updated"));
-            berkley
+            sm.setDateSysMetadataModified(dateUpdated);
-            jones
+        } catch (Exception e) {
-            berkley
+            System.out.println("POSSIBLE ERROR: couldn't parse a date: " + e.getMessage());
-            berkley
+            Date dateCreated = new Date();
             sm.setDateUploaded(dateCreated);
             Date dateUpdated = new Date();
             sm.setDateSysMetadataModified(dateUpdated);
+        }
         NodeReference nr = new NodeReference();
-            jones
+        nr.setValue(PropertyService.getProperty("dataone.memberNodeId"));
-            berkley
+        sm.setOriginMemberNode(nr);
         sm.setAuthoritativeMemberNode(nr);
             jones
         // TODO: Need to set describes/describedBy
-            berkley
+        return sm;
+    }
             berkley
     /**
      * create the listObjects pathQuery document
      */
-            jones
+//    private String createListObjectsPathQueryDocument()
 //        throws PropertyNotFoundException
 //    {
 //        String s = "<pathquery>";
 //        s += "<returndoctype>" + PropertyService.getProperty("crudService.listObjects.ReturnDoctype") + "</returndoctype>";
 //        s += "<returnfield>" + PropertyService.getProperty("crudService.listObjects.ReturnField.1") + "</returnfield>";
 //        s += "<returnfield>" + PropertyService.getProperty("crudService.listObjects.ReturnField.2") + "</returnfield>";
 //        s += "<returnfield>" + PropertyService.getProperty("crudService.listObjects.ReturnField.3") + "</returnfield>";
 //        s += "<returnfield>" + PropertyService.getProperty("crudService.listObjects.ReturnField.4") + "</returnfield>";
 //        s += "<returnfield>" + PropertyService.getProperty("crudService.listObjects.ReturnField.5") + "</returnfield>";
 //        s += "<returnfield>" + PropertyService.getProperty("crudService.listObjects.ReturnField.6") + "</returnfield>";
 //        s += "<returnfield>" + PropertyService.getProperty("crudService.listObjects.ReturnField.7") + "</returnfield>";
 //        s += "<querygroup operator=\"UNION\"><queryterm casesensitive=\"false\" searchmode=\"contains\">";
 //        s += "<value>%</value>";
 //        s += "<pathexpr>" + PropertyService.getProperty("crudService.listObjects.ReturnField.3") + "</pathexpr>";
 //        s += "</queryterm></querygroup></pathquery>";
 //
 //        return s;
 //    }
             jones

Project

General

Profile

Metacat