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

metacat/src/edu/ucsb/nceas/metacat/IdentifierManager.java @ 9091

-            jones
+/**
  *  '$RCSfile$'
  *  Copyright: 2010 Regents of the University of California and the
  *             National Center for Ecological Analysis and Synthesis
+ *
  *   '$Author: jones $'
  *     '$Date: 2010-02-03 17:58:12 -0900 (Wed, 03 Feb 2010) $'
  * '$Revision: 5211 $'
+ *
  * 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;
-            cjones
+import java.math.BigInteger;
-            jones
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-            berkley
+import java.sql.Timestamp;
-            leinfelder
+import java.util.ArrayList;
 import java.util.Date;
 import java.util.Hashtable;
 import java.util.List;
 import java.util.Vector;
             jones
 import org.apache.log4j.Logger;
-            leinfelder
+import org.dataone.client.v2.formats.ObjectFormatCache;
-            cjones
+import org.dataone.service.exceptions.BaseException;
-            cjones
+import org.dataone.service.exceptions.InvalidSystemMetadata;
-            leinfelder
+import org.dataone.service.types.v1.AccessPolicy;
 import org.dataone.service.types.v1.AccessRule;
 import org.dataone.service.types.v1.Checksum;
 import org.dataone.service.types.v1.Identifier;
 import org.dataone.service.types.v1.NodeReference;
 import org.dataone.service.types.v1.ObjectFormatIdentifier;
 import org.dataone.service.types.v1.ObjectInfo;
 import org.dataone.service.types.v1.ObjectList;
 import org.dataone.service.types.v1.Permission;
 import org.dataone.service.types.v1.Replica;
 import org.dataone.service.types.v1.ReplicationPolicy;
 import org.dataone.service.types.v1.ReplicationStatus;
 import org.dataone.service.types.v1.Subject;
-            leinfelder
+import org.dataone.service.types.v2.SystemMetadata;
             jones
-            leinfelder
+import edu.ucsb.nceas.metacat.accesscontrol.XMLAccessAccess;
-            jones
+import edu.ucsb.nceas.metacat.database.DBConnection;
 import edu.ucsb.nceas.metacat.database.DBConnectionPool;
-            leinfelder
+import edu.ucsb.nceas.metacat.database.DatabaseService;
-            berkley
+import edu.ucsb.nceas.metacat.properties.PropertyService;
-            leinfelder
+import edu.ucsb.nceas.metacat.shared.AccessException;
-            leinfelder
+import edu.ucsb.nceas.metacat.shared.ServiceException;
-            jones
+import edu.ucsb.nceas.metacat.util.DocumentUtil;
-            leinfelder
+import edu.ucsb.nceas.utilities.PropertyNotFoundException;
-            leinfelder
+import edu.ucsb.nceas.utilities.access.AccessControlInterface;
 import edu.ucsb.nceas.utilities.access.XMLAccessDAO;
             jones
 /**
  * Manage the relationship between Metacat local identifiers (LocalIDs) that are
-            leinfelder
+ * codified as the (docid, rev) pair with globally unique string identifiers
-            jones
+ * (GUIDs) that are opaque strings.  This class provides methods to manage these
  * identifiers, and to search for and look up LocalIDs based on their GUID and
  * vice versa. IdentifierManager is a singleton.
+ *
  * @author Matthew Jones
  */
 public class IdentifierManager {
-            berkley
+    public static final String TYPE_SYSTEM_METADATA = "systemmetadata";
     public static final String TYPE_IDENTIFIER = "identifier";
-            jones
+    /**
      * The single instance of the manager that is always returned.
      */
     private static IdentifierManager self = null;
-            leinfelder
+    private Logger logMetacat = Logger.getLogger(IdentifierManager.class);
             jones
     /**
      * A private constructor that initializes the class when getInstance() is
      * called.
      */
-            leinfelder
+    private IdentifierManager() {}
             jones
     /**
      * Return the single instance of the manager after initializing it if it
      * wasn't previously initialized.
+     *
      * @return the single IdentifierManager instance
      */
     public static IdentifierManager getInstance()
+    {
         if (self == null) {
             self = new IdentifierManager();
+        }
         return self;
+    }
-            leinfelder
+    public SystemMetadata asSystemMetadata(Date dateUploaded, String rightsHolder,
             String checksum, String checksumAlgorithm, String originMemberNode,
             String authoritativeMemberNode, Date dateModified, String submitter,
-            leinfelder
+            String guid, String fmtidStr, BigInteger size, BigInteger serialVersion) {
-            leinfelder
+        SystemMetadata sysMeta = new SystemMetadata();
         Identifier sysMetaId = new Identifier();
         sysMetaId.setValue(guid);
         sysMeta.setIdentifier(sysMetaId);
         sysMeta.setDateUploaded(dateUploaded);
         Subject rightsHolderSubject = new Subject();
         rightsHolderSubject.setValue(rightsHolder);
         sysMeta.setRightsHolder(rightsHolderSubject);
         Checksum checksumObject = new Checksum();
         checksumObject.setValue(checksum);
-            leinfelder
+        checksumObject.setAlgorithm(checksumAlgorithm);
-            leinfelder
+        sysMeta.setChecksum(checksumObject);
         NodeReference omn = new NodeReference();
         omn.setValue(originMemberNode);
         sysMeta.setOriginMemberNode(omn);
         NodeReference amn = new NodeReference();
         amn.setValue(authoritativeMemberNode);
         sysMeta.setAuthoritativeMemberNode(amn);
         sysMeta.setDateSysMetadataModified(dateModified);
         Subject submitterSubject = new Subject();
         submitterSubject.setValue(submitter);
         sysMeta.setSubmitter(submitterSubject);
-            cjones
+        ObjectFormatIdentifier fmtid = null;
-            cjones
+        try {
-            cjones
+        	ObjectFormatIdentifier formatId = new ObjectFormatIdentifier();
         	formatId.setValue(fmtidStr);
         	fmtid = ObjectFormatCache.getInstance().getFormat(formatId).getFormatId();
-            leinfelder
+        	sysMeta.setFormatId(fmtid);
             cjones
         } catch (BaseException nfe) {
             logMetacat.error("The objectFormat " + fmtidStr +
-            cjones
+          	" is not registered. Setting the default format id.");
-            cjones
+            fmtid = new ObjectFormatIdentifier();
             fmtid.setValue("application/octet-stream");
             sysMeta.setFormatId(fmtid);
             cjones
-            leinfelder
+        sysMeta.setSize(size);
-            leinfelder
+        sysMeta.setSerialVersion(serialVersion);
             leinfelder
         return sysMeta;
+    }
-            jones
+    /**
-            berkley
+     * return a hash of all of the info that is in the systemmetadata table
      * @param localId
      * @return
      */
     public Hashtable<String, String> getSystemMetadataInfo(String localId)
     throws McdbDocNotFoundException
+    {
         try
+        {
             AccessionNumber acc = new AccessionNumber(localId, "NONE");
             localId = acc.getDocid();
+        }
         catch(Exception e)
+        {
             //do nothing. just try the localId as it is
+        }
         Hashtable<String, String> h = new Hashtable<String, String>();
         String sql = "select guid, date_uploaded, rights_holder, checksum, checksum_algorithm, " +
-            berkley
+          "origin_member_node, authoritive_member_node, date_modified, submitter, object_format, size " +
-            berkley
+          "from systemmetadata where docid = ?";
         DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getDocumentInfo");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
             stmt.setString(1, localId);
             ResultSet rs = stmt.executeQuery();
             if (rs.next())
+            {
                 String guid = rs.getString(1);
                 Timestamp dateUploaded = rs.getTimestamp(2);
                 String rightsHolder = rs.getString(3);
                 String checksum = rs.getString(4);
                 String checksumAlgorithm = rs.getString(5);
                 String originMemberNode = rs.getString(6);
                 String authoritativeMemberNode = rs.getString(7);
                 Timestamp dateModified = rs.getTimestamp(8);
                 String submitter = rs.getString(9);
-            berkley
+                String objectFormat = rs.getString(10);
                 long size = new Long(rs.getString(11)).longValue();
             berkley
                 h.put("guid", guid);
                 h.put("date_uploaded", new Long(dateUploaded.getTime()).toString());
                 h.put("rights_holder", rightsHolder);
                 h.put("checksum", checksum);
                 h.put("checksum_algorithm", checksumAlgorithm);
                 h.put("origin_member_node", originMemberNode);
                 h.put("authoritative_member_node", authoritativeMemberNode);
                 h.put("date_modified", new Long(dateModified.getTime()).toString());
                 h.put("submitter", submitter);
-            berkley
+                h.put("object_format", objectFormat);
                 h.put("size", new Long(size).toString());
             berkley
                 stmt.close();
+            }
             else
+            {
                 stmt.close();
                 DBConnectionPool.returnDBConnection(dbConn, serialNumber);
                 throw new McdbDocNotFoundException("2Could not find document " + localId);
+            }
+        }
         catch (SQLException e)
+        {
             e.printStackTrace();
             logMetacat.error("Error while getting system metadata info for localid " + localId + " : "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return h;
+    }
     /**
-            leinfelder
+     * return a hash of all of the info that is in the systemmetadata table
-            leinfelder
+     * @param guid
-            leinfelder
+     * @return
-            leinfelder
+     * @throws McdbDocNotFoundException
-            leinfelder
+     */
-            leinfelder
+    public SystemMetadata getSystemMetadata(String guid)
-            leinfelder
+    	throws McdbDocNotFoundException
+    {
             leinfelder
-            leinfelder
+        SystemMetadata sysMeta = new SystemMetadata();
         String sql = "select guid, date_uploaded, rights_holder, checksum, checksum_algorithm, " +
-            leinfelder
+          "origin_member_node, authoritive_member_node, date_modified, submitter, object_format, size, " +
-            tao
+          "replication_allowed, number_replicas, obsoletes, obsoleted_by, serial_version, archived, series_id " +
-            leinfelder
+          "from systemmetadata where guid = ?";
-            leinfelder
+        DBConnection dbConn = null;
         int serialNumber = -1;
-            cjones
+        Boolean replicationAllowed = new Boolean(false);
         BigInteger numberOfReplicas = new BigInteger("-1");
-            leinfelder
+        BigInteger serialVersion = new BigInteger("-1");
-            leinfelder
+        Boolean archived = new Boolean(false);
             leinfelder
-            leinfelder
+        try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getSystemMetadata");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
-            leinfelder
+            stmt.setString(1, guid);
-            leinfelder
+            ResultSet rs = stmt.executeQuery();
             if (rs.next())
+            {
                 Timestamp dateUploaded = rs.getTimestamp(2);
                 String rightsHolder = rs.getString(3);
                 String checksum = rs.getString(4);
                 String checksumAlgorithm = rs.getString(5);
                 String originMemberNode = rs.getString(6);
                 String authoritativeMemberNode = rs.getString(7);
                 Timestamp dateModified = rs.getTimestamp(8);
                 String submitter = rs.getString(9);
-            cjones
+                String fmtidStr = rs.getString(10);
-            cjones
+                BigInteger size = new BigInteger(rs.getString(11));
-            cjones
+                replicationAllowed = new Boolean(rs.getBoolean(12));
-            cjones
+                numberOfReplicas = new BigInteger(rs.getString(13));
                 String obsoletes = rs.getString(14);
                 String obsoletedBy = rs.getString(15);
-            leinfelder
+                serialVersion = new BigInteger(rs.getString(16));
-            leinfelder
+                archived = new Boolean(rs.getBoolean(17));
-            tao
+                String series_id = rs.getString(18);
             leinfelder
-            leinfelder
+                Identifier sysMetaId = new Identifier();
                 sysMetaId.setValue(guid);
                 sysMeta.setIdentifier(sysMetaId);
-            leinfelder
+                sysMeta.setSerialVersion(serialVersion);
-            leinfelder
+                sysMeta.setDateUploaded(dateUploaded);
                 Subject rightsHolderSubject = new Subject();
                 rightsHolderSubject.setValue(rightsHolder);
                 sysMeta.setRightsHolder(rightsHolderSubject);
                 Checksum checksumObject = new Checksum();
                 checksumObject.setValue(checksum);
-            leinfelder
+                checksumObject.setAlgorithm(checksumAlgorithm);
-            leinfelder
+                sysMeta.setChecksum(checksumObject);
-            leinfelder
+                if (originMemberNode != null) {
 	                NodeReference omn = new NodeReference();
 	                omn.setValue(originMemberNode);
 	                sysMeta.setOriginMemberNode(omn);
+                }
                 if (authoritativeMemberNode != null) {
 	                NodeReference amn = new NodeReference();
 	                amn.setValue(authoritativeMemberNode);
 	                sysMeta.setAuthoritativeMemberNode(amn);
+                }
-            leinfelder
+                sysMeta.setDateSysMetadataModified(dateModified);
-            leinfelder
+                if (submitter != null) {
 	                Subject submitterSubject = new Subject();
 	                submitterSubject.setValue(submitter);
 	                sysMeta.setSubmitter(submitterSubject);
+                }
-            leinfelder
+                ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();
                 fmtid.setValue(fmtidStr);
             	sysMeta.setFormatId(fmtid);
-            leinfelder
+                sysMeta.setSize(size);
-            leinfelder
+                if (obsoletes != null) {
 	                Identifier obsoletesId = new Identifier();
 	                obsoletesId.setValue(obsoletes);
 	                sysMeta.setObsoletes(obsoletesId);
+                }
                 if (obsoletedBy != null) {
 		            Identifier obsoletedById = new Identifier();
 		            obsoletedById.setValue(obsoletedBy);
 		            sysMeta.setObsoletedBy(obsoletedById);
+                }
-            leinfelder
+                sysMeta.setArchived(archived);
-            tao
+                if(series_id != null) {
                     Identifier seriesId = new Identifier();
                     seriesId.setValue(series_id);
                     sysMeta.setSeriesId(seriesId);
+                }
-            leinfelder
+                stmt.close();
+            }
             else
+            {
                 stmt.close();
                 DBConnectionPool.returnDBConnection(dbConn, serialNumber);
-            leinfelder
+                throw new McdbDocNotFoundException("Could not find " + guid);
             leinfelder
+        }
         catch (SQLException e)
+        {
             e.printStackTrace();
-            leinfelder
+            logMetacat.error("Error while getting system metadata for guid " + guid + " : "
-            leinfelder
+                    + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
             leinfelder
-            cjones
+        // populate the replication policy
-            leinfelder
+        ReplicationPolicy replicationPolicy = new ReplicationPolicy();
-            cjones
+        if ( numberOfReplicas != null  && numberOfReplicas.intValue() != -1 ) {
             replicationPolicy.setNumberReplicas(numberOfReplicas.intValue());
+        }
         if ( replicationAllowed != null ) {
             replicationPolicy.setReplicationAllowed(replicationAllowed);
+        }
-            leinfelder
+        replicationPolicy.setBlockedMemberNodeList(getReplicationPolicy(guid, "blocked"));
         replicationPolicy.setPreferredMemberNodeList(getReplicationPolicy(guid, "preferred"));
-            cjones
+		    sysMeta.setReplicationPolicy(replicationPolicy);
             leinfelder
-            cjones
+		    // look up replication status
 		    sysMeta.setReplicaList(getReplicationStatus(guid));
             leinfelder
-            cjones
+		    // look up access policy
 		    try {
 		    	sysMeta.setAccessPolicy(getAccessPolicy(guid));
 		    } catch (AccessException e) {
 		    	throw new McdbDocNotFoundException(e);
+		    }
             leinfelder
-            leinfelder
+        return sysMeta;
+    }
-            leinfelder
+    private List<NodeReference> getReplicationPolicy(String guid, String policy)
 		throws McdbDocNotFoundException {
 		List<NodeReference> nodes = new ArrayList<NodeReference>();
 		String sql = "select guid, policy, member_node " +
-            leinfelder
+			"from smReplicationPolicy where guid = ? and policy = ?";
-            leinfelder
+	    DBConnection dbConn = null;
 	    int serialNumber = -1;
 	    try {
 	        // Get a database connection from the pool
 	        dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getReplicationPolicy");
 	        serialNumber = dbConn.getCheckOutSerialNumber();
 	        // Execute the statement
 	        PreparedStatement stmt = dbConn.prepareStatement(sql);
 	        stmt.setString(1, guid);
 	        stmt.setString(2, policy);
 	        ResultSet rs = stmt.executeQuery();
 	        while (rs.next())
+	        {
 	            String memberNode = rs.getString(3);
 	            NodeReference node = new NodeReference();
 	            node.setValue(memberNode);
 	            nodes.add(node);
+	        }
 	        stmt.close();
 	    } catch (SQLException e) {
 	        logMetacat.error("Error while getting system metadata replication policy for guid " + guid, e);
+	    }
 	    finally {
 	        // Return database connection to the pool
 	        DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+	    }
 	    return nodes;
+	}
             leinfelder
-            leinfelder
+    private List<Replica> getReplicationStatus(String guid) throws McdbDocNotFoundException {
 		List<Replica> replicas = new ArrayList<Replica>();
 		String sql = "select guid, member_node, status, date_verified " +
-            leinfelder
+			"from smReplicationStatus where guid = ?";
-            leinfelder
+	    DBConnection dbConn = null;
 	    int serialNumber = -1;
 	    try {
 	        // Get a database connection from the pool
 	        dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getReplicas");
 	        serialNumber = dbConn.getCheckOutSerialNumber();
 	        // Execute the statement
 	        PreparedStatement stmt = dbConn.prepareStatement(sql);
 	        stmt.setString(1, guid);
 	        ResultSet rs = stmt.executeQuery();
 	        while (rs.next())
+	        {
 	            String memberNode = rs.getString(2);
 	            String status = rs.getString(3);
-            cjones
+	            java.sql.Timestamp verified = rs.getTimestamp(4);
             leinfelder
 	            Replica replica = new Replica();
 	            NodeReference node = new NodeReference();
 	            node.setValue(memberNode);
 	            replica.setReplicaMemberNode(node);
-            leinfelder
+	            replica.setReplicationStatus(ReplicationStatus.valueOf(status));
-            leinfelder
+	            replica.setReplicaVerified(new Date(verified.getTime()));
 	            replicas.add(replica);
+	        }
 	        stmt.close();
 	    } catch (SQLException e) {
 	        logMetacat.error("Error while getting system metadata replication policy for guid " + guid, e);
+	    }
 	    finally {
 	        // Return database connection to the pool
 	        DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+	    }
 	    return replicas;
+	}
             berkley
     /**
      * return the newest rev for a given localId
      * @param localId
      * @return
      */
     public int getLatestRevForLocalId(String localId)
         throws McdbDocNotFoundException
+    {
-            berkley
+        try
+        {
             AccessionNumber acc = new AccessionNumber(localId, "NONE");
             localId = acc.getDocid();
+        }
         catch(Exception e)
+        {
             //do nothing. just try the localId as it is
+        }
-            berkley
+        int rev = 0;
-            leinfelder
+        String sql = "select rev from xml_documents where docid like ? ";
-            berkley
+        DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getLatestRevForLocalId");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
-            leinfelder
+            stmt.setString(1, localId);
-            berkley
+            ResultSet rs = stmt.executeQuery();
             if (rs.next())
+            {
                 rev = rs.getInt(1);
                 stmt.close();
+            }
             else
+            {
                 stmt.close();
                 DBConnectionPool.returnDBConnection(dbConn, serialNumber);
-            berkley
+                throw new McdbDocNotFoundException("While trying to get the latest rev, could not find document " + localId);
             berkley
+        }
         catch (SQLException e)
+        {
             logMetacat.error("Error while looking up the guid: "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return rev;
+    }
     /**
-            berkley
+     * return all local ids in the object store that do not have associated
-            leinfelder
+     * system metadata
-            berkley
+     */
-            leinfelder
+    public List<String> getLocalIdsWithNoSystemMetadata(boolean includeRevisions, int serverLocation)
             berkley
         Vector<String> ids = new Vector<String>();
-            leinfelder
+        String sql = "select docid, rev from xml_documents " +
         		"where docid not in " +
-            leinfelder
+        		"(select docid from identifier where guid in (select guid from systemmetadata))";
-            leinfelder
+        if (serverLocation > 0) {
         	sql = sql + " and server_location = ? ";
+        }
             leinfelder
-            leinfelder
+        String revisionSql = "select docid, rev from xml_revisions " +
-            leinfelder
+				"where docid not in " +
-            leinfelder
+				"(select docid from identifier where guid in (select guid from systemmetadata))";
-            leinfelder
+        if (serverLocation > 0) {
         	revisionSql = revisionSql + " and server_location = ? ";
+        }
             leinfelder
         if (includeRevisions) {
         	sql = sql + " UNION ALL " + revisionSql;
+        }
-            berkley
+        DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getLocalIdsWithNoSystemMetadata");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
-            leinfelder
+            // set params based on what we have in the query string
             if (serverLocation > 0) {
             	stmt.setInt(1, serverLocation);
             	if (includeRevisions) {
             		stmt.setInt(2, serverLocation);
+            	}
+            }
-            berkley
+            ResultSet rs = stmt.executeQuery();
             while (rs.next())
+            {
                 String localid = rs.getString(1);
-            berkley
+                String rev = rs.getString(2);
                 localid += "." + rev;
-            leinfelder
+                logMetacat.debug("id to add SM for: " + localid);
-            berkley
+                ids.add(localid);
+            }
             stmt.close();
+        }
         catch (SQLException e)
+        {
             logMetacat.error("Error while looking up the guid: "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return ids;
+    }
     /**
      * return a listing of all local ids in the object store
      * @return a list of all local ids in metacat
      */
     public List<String> getAllLocalIds()
-            rnahf
+    // seems to be an unnecessary and restrictive throw -rnahf 13-Sep-2011
     //    throws Exception
             berkley
         Vector<String> ids = new Vector<String>();
         String sql = "select docid from xml_documents";
         DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getAllLocalIds");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
             ResultSet rs = stmt.executeQuery();
             while (rs.next())
+            {
                 String localid = rs.getString(1);
                 ids.add(localid);
+            }
             stmt.close();
+        }
         catch (SQLException e)
+        {
             logMetacat.error("Error while looking up the guid: "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return ids;
+    }
             rnahf
-            leinfelder
+    /**
-            rnahf
+     * return a listing of all guids in the object store
      * @return a list of all GUIDs in metacat
      */
-            leinfelder
+    public List<String> getAllSystemMetadataGUIDs()
             rnahf
         Vector<String> guids = new Vector<String>();
-            leinfelder
+        String sql = "select guid from systemmetadata";
-            rnahf
+        DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getAllGUIDs");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
             ResultSet rs = stmt.executeQuery();
             while (rs.next())
+            {
                 String guid = rs.getString(1);
                 guids.add(guid);
+            }
             stmt.close();
+        }
         catch (SQLException e)
+        {
             logMetacat.error("Error while retrieving the guid: "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return guids;
+    }
     /**
-            leinfelder
+     * returns a list of system metadata-only guids since the given date
      * @return a list of system ids in metacat that do not correspond to objects
      * TODO: need to check which server they are on
      */
     public List<String> getUpdatedSystemMetadataIds(Date since)
        throws Exception
+    {
         List<String> ids = new Vector<String>();
         String sql =
         	"select guid from " + TYPE_SYSTEM_METADATA +
         	" where guid not in " +
         	" (select guid from " + TYPE_IDENTIFIER + ") " +
         	" and date_modified > ?";
         DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getUpdatedSystemMetadataIds");
             serialNumber = dbConn.getCheckOutSerialNumber();
             leinfelder
-            leinfelder
+            // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
             stmt.setDate(1, new java.sql.Date(since.getTime()));
             ResultSet rs = stmt.executeQuery();
             while (rs.next())
+            {
                 String guid = rs.getString(1);
                 ids.add(guid);
+            }
             stmt.close();
+        }
         catch (SQLException e)
+        {
             logMetacat.error("Error while looking up the updated guids: "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return ids;
+    }
             jones
-            leinfelder
+    /**
      * returns a list of system metadata-only guids since the given date
      * @return a list of system ids in metacat that do not correspond to objects
      * TODO: need to check which server they are on
      */
     public Date getLastModifiedDate() throws Exception {
         Date maxDate = null;
             leinfelder
-            leinfelder
+        List<String> ids = new Vector<String>();
         String sql =
         	"select max(date_modified) from " + TYPE_SYSTEM_METADATA;
         DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getLastModifiedDate");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
             ResultSet rs = stmt.executeQuery();
             if (rs.next()) {
             	maxDate = rs.getDate(1);
+            }
             stmt.close();
+        }
         catch (SQLException e)
+        {
             logMetacat.error("Error while looking up the latest update date: "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return maxDate;
+    }
             leinfelder
-            jones
+    /**
      * Determine if an identifier exists already, returning true if so.
-            leinfelder
+     * NOTE: looks in the identifier and system metadata table for a match
      * (in that order)
             jones
      * @param guid the global identifier to look up
      * @return boolean true if the identifier exists
      */
-            tao
+    public boolean identifierExists(String guid) throws SQLException
             jones
         boolean idExists = false;
         try {
             String id = getLocalId(guid);
             if (id != null) {
                 idExists = true;
+            }
         } catch (McdbDocNotFoundException e) {
-            leinfelder
+        	// try system metadata only
-            tao
+        	    //this will check if the guid field on the system metadata table has the id
-            tao
+        		idExists = systemMetadataPIDExists(guid);
-            tao
+        		if(!idExists) {
         		    //if the guid field of the system metadata table doesn't have the id,
         		    //we will check if the serial_id field of the system metadata table has it
         		    idExists=systemMetadataSIDExists(guid);
+        		}
             jones
         return idExists;
+    }
     /**
-            leinfelder
+     * Determine if an identifier mapping exists already,
      * returning true if so.
             jones
-            leinfelder
+     * @param guid the global identifier to look up
      * @return boolean true if the identifier exists
      */
-            tao
+    public boolean mappingExists(String guid) throws SQLException
             leinfelder
         boolean idExists = false;
         try {
             String id = getLocalId(guid);
             if (id != null) {
                 idExists = true;
+            }
         } catch (McdbDocNotFoundException e) {
         	// nope!
+        }
         return idExists;
+    }
     /**
+     *
-            berkley
+     * @param guid
      * @param rev
      * @return
      */
     public String generateLocalId(String guid, int rev)
+    {
         return generateLocalId(guid, rev, false);
+    }
             jones
     /**
      * Given a global identifier (guid), create a suitable local identifier that
      * follows Metacat's docid semantics and format (scope.id.rev), and create
      * a mapping between these two identifiers.  This effectively reserves both
      * the global and the local identifier, as they will now be present in the
-            leinfelder
+     * identifier mapping table.
+     *
      * REMOVED feature: If the incoming guid has the syntax of a
-            jones
+     * Metacat docid (scope.id.rev), then simply use it.
-            leinfelder
+     * WHY: because "test.1.001" becomes "test.1.1" which is not correct for DataONE
      * identifier use (those revision numbers are just chartacters and should not be interpreted)
             jones
      * @param guid the global string identifier
      * @param rev the revision number to be used in the localId
      * @return String containing the localId to be used for Metacat operations
      */
-            berkley
+    public String generateLocalId(String guid, int rev, boolean isSystemMetadata)
             jones
         String localId = "";
         boolean conformsToDocidFormat = false;
-            leinfelder
+        // BRL -- do not allow Metacat-conforming IDs to be used:
         // test.1.001 becomes test.1.1 which is NOT correct for DataONE identifiers
-            jones
+        // Check if the guid passed in is already in docid (scope.id.rev) format
-            leinfelder
+//        try {
 //            AccessionNumber acc = new AccessionNumber(guid, "NONE");
 //            if (new Integer(acc.getRev()).intValue() > 0) {
 //                conformsToDocidFormat = true;
 //            }
 //        } catch (NumberFormatException e) {
 //            // No action needed, simply detecting invalid AccessionNumbers
 //        } catch (AccessionNumberException e) {
 //            // No action needed, simply detecting invalid AccessionNumbers
 //        } catch (SQLException e) {
 //            // No action needed, simply detecting invalid AccessionNumbers
 //        }
             jones
         if (conformsToDocidFormat) {
             // if it conforms, use it for both guid and localId
             localId = guid;
         } else {
             // if not, then generate a new unique localId
             localId = DocumentUtil.generateDocumentId(rev);
+        }
         // Register this new pair in the identifier mapping table
-            leinfelder
+        logMetacat.debug("creating mapping in generateLocalId");
-            berkley
+        if(!isSystemMetadata)
         { //don't do this if we're generating for system metadata
             createMapping(guid, localId);
+        }
             jones
         return localId;
+    }
             berkley
     /**
      * given a local identifer, look up the guid.  Throw McdbDocNotFoundException
-            berkley
+     * if the docid, rev is not found in the identifiers or systemmetadata tables
             berkley
      * @param docid the docid to look up
      * @param rev the revision of the docid to look up
      * @return String containing the mapped guid
      * @throws McdbDocNotFoundException if the docid, rev is not found
      */
     public String getGUID(String docid, int rev)
       throws McdbDocNotFoundException
+    {
-            leinfelder
+        logMetacat.debug("getting guid for " + docid);
-            berkley
+        String query = "select guid from identifier where docid = ? and rev = ?";
         String guid = null;
         DBConnection dbConn = null;
         int serialNumber = -1;
         try {
             // Get a database connection from the pool
-            berkley
+            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getGUID");
-            berkley
+            serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(query);
             stmt.setString(1, docid);
             stmt.setInt(2, rev);
             ResultSet rs = stmt.executeQuery();
-            berkley
+            if (rs.next())
+            {
-            berkley
+                guid = rs.getString(1);
             berkley
             else
+            {
-            leinfelder
+            	throw new McdbDocNotFoundException("No guid registered for docid " + docid + "." + rev);
             berkley
             berkley
-            berkley
+        } catch (SQLException e) {
             logMetacat.error("Error while looking up the guid: "
                     + e.getMessage());
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return guid;
+    }
             berkley
-            tao
+    /**
      * Get the pid of the head (current) version of objects match the specified sid.
      * DataONE defines the latest version as "current" if the object in question has
      * a matching SID and no value in the "obsoletedBy" field, regardless if it is "archived" or not.
-            tao
+     * If we can't find any pid associated with the sid doesn't have a value in obsoletedBy field,
      * the pid associated with the sid  which has the max date_uploaded will be returned
-            tao
+     * @param sid specified sid which should match.
      * @return the pid of the head version. The null will be returned if there is no pid found.
-            tao
+     * @throws SQLException
-            tao
+     */
-            tao
+    public Identifier getHeadPID(Identifier sid) throws SQLException {
-            tao
+        Identifier pid = null;
         if(sid != null && sid.getValue() != null && !sid.getValue().trim().equals("")) {
             logMetacat.debug("getting pid of the head version for matching the sid: " + sid.getValue());
             String sql = "select guid from systemMetadata where obsoleted_by is null and series_id = ?";
             DBConnection dbConn = null;
             int serialNumber = -1;
             try {
                 // Get a database connection from the pool
                 dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getHeadPID");
                 serialNumber = dbConn.getCheckOutSerialNumber();
                 // Execute the insert statement
                 PreparedStatement stmt = dbConn.prepareStatement(sql);
                 stmt.setString(1, sid.getValue());
                 ResultSet rs = stmt.executeQuery();
                 if (rs.next())
+                {
                     pid = new Identifier();
                     pid.setValue(rs.getString(1));
-            tao
+                } else {
                     //we don't find any pid associated with the sid doesn't have value in obsoletedBy field.
                     //The pid associated with the sid  which has the max date_uploaded will be returned.
                     sql = "select guid from systemMetadata where series_id = ? and date_uploaded=(select max(date_uploaded) from systemMetadata where series_id = ?)";
                     stmt = dbConn.prepareStatement(sql);
                     stmt.setString(1, sid.getValue());
                     stmt.setString(2, sid.getValue());
                     rs = stmt.executeQuery();
                     if(rs.next()) {
                         pid = new Identifier();
                         pid.setValue(rs.getString(1));
+                    }
+                }
             tao
             } catch (SQLException e) {
                 logMetacat.error("Error while get the head pid for the sid "+sid.getValue()+" : "
                         + e.getMessage());
-            tao
+                throw e;
-            tao
+            } finally {
                 // Return database connection to the pool
                 DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+            }
+        }
         return pid;
+    }
-            tao
+    /**
-            tao
+     * Check if the specified sid object exists on the serial id field on the system metadata table
      * @param sid
      * @return true if it exists; false otherwise.
      * @throws SQLException
      */
     public boolean systemMetadataSIDExists(Identifier sid) throws SQLException {
         if (sid != null && sid.getValue() != null && !sid.getValue().trim().equals("")) {
             return systemMetadataSIDExists(sid.getValue());
         } else {
             return false;
+        }
+    }
     /**
-            tao
+     * Check if the specified sid exists on the serial id field on the system metadata table
      * @param id
      * @return true if it exists; false otherwise.
      */
-            tao
+    public boolean systemMetadataSIDExists(String sid) throws SQLException {
-            tao
+        boolean exists = false;
-            tao
+        logMetacat.debug("Check if the  sid: " + sid +" exists on the series_id field of the system metadata table.");
-            tao
+        if(sid != null && !sid.trim().equals("")) {
             String sql = "select guid from systemMetadata where series_id = ?";
             DBConnection dbConn = null;
             int serialNumber = -1;
             try {
                 // Get a database connection from the pool
                 dbConn = DBConnectionPool.getDBConnection("IdentifierManager.serialIdExists");
                 serialNumber = dbConn.getCheckOutSerialNumber();
                 // Execute the insert statement
                 PreparedStatement stmt = dbConn.prepareStatement(sql);
                 stmt.setString(1, sid);
                 ResultSet rs = stmt.executeQuery();
                 if (rs.next())
+                {
                     exists = true;
+                }
             } catch (SQLException e) {
                 logMetacat.error("Error while checking if the sid "+sid+" exists on the series_id field of the system metadata table: "
                         + e.getMessage());
                 throw e;
             } finally {
                 // Return database connection to the pool
                 DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+            }
+        }
         return exists;
+    }
-            tao
+    /**
      * Determine if the specified identifier object exists or not.
      * @param pid - the specified identifier
      * @return true if it is exists.
      * @throws SQLException
      * @throws NullPointerException
      */
     public boolean systemMetadataPIDExists(Identifier pid) throws SQLException {
         if (pid != null && pid.getValue() != null && !pid.getValue().trim().equals("")) {
             return systemMetadataPIDExists(pid.getValue());
         } else {
             return false;
+        }
+    }
-            tao
+    public boolean systemMetadataPIDExists(String guid) throws SQLException {
-            leinfelder
+		logMetacat.debug("looking up system metadata for guid " + guid);
 		boolean exists = false;
-            leinfelder
+		String query = "select guid from systemmetadata where guid = ?";
-            leinfelder
+		DBConnection dbConn = null;
 		int serialNumber = -1;
-            tao
+		if(guid != null && !guid.trim().equals("")) {
 		    try {
 	            // Get a database connection from the pool
 	            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.systemMetadataExisits");
 	            serialNumber = dbConn.getCheckOutSerialNumber();
             leinfelder
-            tao
+	            // Execute the insert statement
 	            PreparedStatement stmt = dbConn.prepareStatement(query);
 	            stmt.setString(1, guid);
 	            ResultSet rs = stmt.executeQuery();
 	            if (rs.next()) {
 	                exists = true;
+	            }
             leinfelder
-            tao
+	        } catch (SQLException e) {
 	            logMetacat.error("Error while looking up the system metadata: "
 	                    + e.getMessage());
 	            throw e;
 	        } finally {
 	            // Return database connection to the pool
 	            DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+	        }
             leinfelder
 		return exists;
+	}
-            berkley
+    /**
-            berkley
+     * creates a system metadata mapping and adds additional fields from sysmeta
      * to the table for quick searching.
+     *
      * @param guid the id to insert
      * @param localId the systemMetadata object to get the local id for
-            leinfelder
+     * @throws McdbDocNotFoundException
-            cjones
+     * @throws SQLException
-            cjones
+     * @throws InvalidSystemMetadata
-            berkley
+     */
-            leinfelder
+    public void insertOrUpdateSystemMetadata(SystemMetadata sysmeta)
-            cjones
+        throws McdbDocNotFoundException, SQLException, InvalidSystemMetadata {
-            leinfelder
+    	String guid = sysmeta.getIdentifier().getValue();
             leinfelder
     	 // Get a database connection from the pool
         DBConnection dbConn = DBConnectionPool.getDBConnection("IdentifierManager.insertSystemMetadata");
         int serialNumber = dbConn.getCheckOutSerialNumber();
             cjones
-            leinfelder
+        try {
         	// use a single transaction for it all
         	dbConn.setAutoCommit(false);
 	    	// insert the record if needed
-            tao
+        	if (!IdentifierManager.getInstance().systemMetadataPIDExists(guid)) {
-            leinfelder
+    	        insertSystemMetadata(guid, dbConn);
+			}
 	        // update with the values
 	        updateSystemMetadata(sysmeta, dbConn);
 	        // commit if we got here with no errors
 	        dbConn.commit();
         } catch (Exception e) {
             e.printStackTrace();
             logMetacat.error("Error while creating " + TYPE_SYSTEM_METADATA + " record: " + guid, e );
             dbConn.rollback();
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
             berkley
             leinfelder
             berkley
     /**
-            leinfelder
+     * update a mapping
      * @param guid
      * @param localId
      */
     public void updateMapping(String guid, String localId)
+    {
-            leinfelder
+        logMetacat.debug("$$$$$$$$$$$$$$ updating mapping table");
-            berkley
+        int serialNumber = -1;
         DBConnection dbConn = null;
         try {
             // Parse the localId into scope and rev parts
             AccessionNumber acc = new AccessionNumber(localId, "NOACTION");
             String docid = acc.getDocid();
             int rev = 1;
             if(acc.getRev() != null)
+            {
               rev = (new Integer(acc.getRev()).intValue());
+            }
             // Get a database connection from the pool
             dbConn =
-            leinfelder
+                DBConnectionPool.getDBConnection("IdentifierManager.updateMapping");
-            berkley
+            serialNumber = dbConn.getCheckOutSerialNumber();
-            leinfelder
+            // Execute the update statement
-            leinfelder
+            String query = "update " + TYPE_IDENTIFIER + " set (docid, rev) = (?, ?) where guid = ?";
-            berkley
+            PreparedStatement stmt = dbConn.prepareStatement(query);
             stmt.setString(1, docid);
             stmt.setInt(2, rev);
-            leinfelder
+            stmt.setString(3, guid);
-            berkley
+            int rows = stmt.executeUpdate();
             stmt.close();
         } catch (SQLException e) {
             e.printStackTrace();
-            leinfelder
+            logMetacat.error("SQL error while updating a mapping identifier: "
-            berkley
+                    + e.getMessage());
         } catch (NumberFormatException e) {
             e.printStackTrace();
-            leinfelder
+            logMetacat.error("NumberFormat error while updating a mapping identifier: "
-            berkley
+                    + e.getMessage());
         } catch (AccessionNumberException e) {
             e.printStackTrace();
-            leinfelder
+            logMetacat.error("AccessionNumber error while updating a mapping identifier: "
-            berkley
+                    + e.getMessage());
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
-            leinfelder
+        logMetacat.debug("done updating mapping");
             berkley
             leinfelder
     private void updateSystemMetadataFields(long dateUploaded, String rightsHolder,
-            cjones
+        String checksum, String checksumAlgorithm, String originMemberNode,
         String authoritativeMemberNode, long modifiedDate, String submitter,
         String guid, String objectFormat, BigInteger size, boolean archived,
         boolean replicationAllowed, int numberReplicas, String obsoletes,
-            leinfelder
+        String obsoletedBy, BigInteger serialVersion, String seriesId, DBConnection dbConn) throws SQLException  {
             leinfelder
         // Execute the insert statement
         String query = "update " + TYPE_SYSTEM_METADATA +
             " set (date_uploaded, rights_holder, checksum, checksum_algorithm, " +
             "origin_member_node, authoritive_member_node, date_modified, " +
             "submitter, object_format, size, archived, replication_allowed, number_replicas, " +
-            leinfelder
+            "obsoletes, obsoleted_by, serial_version, series_id) " +
             "= (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) where guid = ?";
-            leinfelder
+        PreparedStatement stmt = dbConn.prepareStatement(query);
             cjones
-            leinfelder
+        //data values
         stmt.setTimestamp(1, new java.sql.Timestamp(dateUploaded));
         stmt.setString(2, rightsHolder);
         stmt.setString(3, checksum);
         stmt.setString(4, checksumAlgorithm);
         stmt.setString(5, originMemberNode);
         stmt.setString(6, authoritativeMemberNode);
         stmt.setTimestamp(7, new java.sql.Timestamp(modifiedDate));
         stmt.setString(8, submitter);
         stmt.setString(9, objectFormat);
         stmt.setString(10, size.toString());
         stmt.setBoolean(11, archived);
         stmt.setBoolean(12, replicationAllowed);
         stmt.setInt(13, numberReplicas);
         stmt.setString(14, obsoletes);
         stmt.setString(15, obsoletedBy);
         stmt.setString(16, serialVersion.toString());
-            leinfelder
+        stmt.setString(17, seriesId);
             leinfelder
             leinfelder
-            leinfelder
+        //where clause
-            leinfelder
+        stmt.setString(18, guid);
-            leinfelder
+        logMetacat.debug("stmt: " + stmt.toString());
         //execute
         int rows = stmt.executeUpdate();
         stmt.close();
+    }
     private void insertReplicationPolicy(String guid, String policy, List<String> memberNodes, DBConnection dbConn) throws SQLException
+    {
         // remove existing values first
-            leinfelder
+        String delete = "delete from smReplicationPolicy " +
-            leinfelder
+        "where guid = ? and policy = ?";
         PreparedStatement stmt = dbConn.prepareStatement(delete);
         //data values
         stmt.setString(1, guid);
         stmt.setString(2, policy);
         //execute
         int deletedCount = stmt.executeUpdate();
         stmt.close();
             berkley
-            leinfelder
+        for (String memberNode: memberNodes) {
-            berkley
+            // Execute the insert statement
-            leinfelder
+            String insert = "insert into smReplicationPolicy " +
-            leinfelder
+                "(guid, policy, member_node) " +
                 "values (?, ?, ?)";
             PreparedStatement insertStatement = dbConn.prepareStatement(insert);
             berkley
             //data values
-            leinfelder
+            insertStatement.setString(1, guid);
             insertStatement.setString(2, policy);
             insertStatement.setString(3, memberNode);
-            leinfelder
+            logMetacat.debug("smReplicationPolicy sql: " + insertStatement.toString());
             leinfelder
-            berkley
+            //execute
-            leinfelder
+            int rows = insertStatement.executeUpdate();
             insertStatement.close();
             berkley
             leinfelder
             berkley
-            leinfelder
+    private void insertReplicationStatus(String guid, List<Replica> replicas, DBConnection dbConn) throws SQLException {
         // remove existing values first
-            leinfelder
+        String delete = "delete from smReplicationStatus " +
-            leinfelder
+        "where guid = ?";
         PreparedStatement stmt = dbConn.prepareStatement(delete);
         //data values
         stmt.setString(1, guid);
         //execute
         int deletedCount = stmt.executeUpdate();
         stmt.close();
             leinfelder
-            leinfelder
+        if (replicas != null) {
             for (Replica replica: replicas) {
-            leinfelder
+	            // Execute the insert statement
-            leinfelder
+	            String insert = "insert into smReplicationStatus " +
-            leinfelder
+	                "(guid, member_node, status, date_verified) " +
 	                "values (?, ?, ?, ?)";
-            leinfelder
+	            PreparedStatement insertStatement = dbConn.prepareStatement(insert);
 	            //data values
-            leinfelder
+	            String memberNode = replica.getReplicaMemberNode().getValue();
 	            String status = replica.getReplicationStatus().toString();
-            cjones
+	            java.sql.Timestamp sqlDate = new java.sql.Timestamp(replica.getReplicaVerified().getTime());
-            leinfelder
+	            insertStatement.setString(1, guid);
-            leinfelder
+	            insertStatement.setString(2, memberNode);
 	            insertStatement.setString(3, status);
-            cjones
+	            insertStatement.setTimestamp(4, sqlDate);
             leinfelder
-            leinfelder
+	            logMetacat.debug("smReplicationStatus sql: " + insertStatement.toString());
             leinfelder
-            leinfelder
+	            //execute
 	            int rows = insertStatement.executeUpdate();
 	            insertStatement.close();
+            }
+        }
             leinfelder
             leinfelder
-            berkley
+    /**
-            berkley
+     * Insert the system metadata fields into the db
      * @param sm
-            leinfelder
+     * @throws McdbDocNotFoundException
-            cjones
+     * @throws SQLException
-            cjones
+     * @throws InvalidSystemMetadata
-            leinfelder
+     * @throws AccessException
-            berkley
+     */
-            leinfelder
+    public void updateSystemMetadata(SystemMetadata sm, DBConnection dbConn)
       throws McdbDocNotFoundException, SQLException, InvalidSystemMetadata, AccessException {
             leinfelder
-            cjones
+      Boolean replicationAllowed = false;
 		  Integer numberReplicas = -1;
-            leinfelder
+    	ReplicationPolicy replicationPolicy = sm.getReplicationPolicy();
     	if (replicationPolicy != null) {
     		replicationAllowed = replicationPolicy.getReplicationAllowed();
     		numberReplicas = replicationPolicy.getNumberReplicas();
     		replicationAllowed = replicationAllowed == null ? false: replicationAllowed;
     		numberReplicas = numberReplicas == null ? -1: numberReplicas;
+    	}
             cjones
-            leinfelder
+    	// the main systemMetadata fields
-            cjones
+		  updateSystemMetadataFields(
-            leinfelder
+				sm.getDateUploaded() == null ? null: sm.getDateUploaded().getTime(),
 				sm.getRightsHolder() == null ? null: sm.getRightsHolder().getValue(),
 				sm.getChecksum() == null ? null: sm.getChecksum().getValue(),
-            leinfelder
+				sm.getChecksum() == null ? null: sm.getChecksum().getAlgorithm(),
-            leinfelder
+				sm.getOriginMemberNode() == null ? null: sm.getOriginMemberNode().getValue(),
 				sm.getAuthoritativeMemberNode() == null ? null: sm.getAuthoritativeMemberNode().getValue(),
 				sm.getDateSysMetadataModified() == null ? null: sm.getDateSysMetadataModified().getTime(),
 				sm.getSubmitter() == null ? null: sm.getSubmitter().getValue(),
-            cjones
+		    sm.getIdentifier().getValue(),
 		    sm.getFormatId() == null ? null: sm.getFormatId().getValue(),
 		    sm.getSize(),
 		    sm.getArchived() == null ? false: sm.getArchived(),
 		    replicationAllowed,
 		    numberReplicas,
 		    sm.getObsoletes() == null ? null:sm.getObsoletes().getValue(),
 		    sm.getObsoletedBy() == null ? null: sm.getObsoletedBy().getValue(),
-            leinfelder
+		    sm.getSerialVersion(),
-            leinfelder
+		    sm.getSeriesId() == null ? null: sm.getSeriesId().getValue(),
-            leinfelder
+		    dbConn
-            leinfelder
+        );
             leinfelder
         String guid = sm.getIdentifier().getValue();
-            leinfelder
+        // save replication policies
         if (replicationPolicy != null) {
 		    List<String> nodes = null;
 		    String policy = null;
-            leinfelder
+		    // check for null
 		    if (replicationPolicy.getBlockedMemberNodeList() != null) {
 			    nodes = new ArrayList<String>();
 			    policy = "blocked";
 			    for (NodeReference node: replicationPolicy.getBlockedMemberNodeList()) {
 			    	nodes.add(node.getValue());
+			    }
-            leinfelder
+			    this.insertReplicationPolicy(guid, policy, nodes, dbConn);
             leinfelder
-            leinfelder
+		    if (replicationPolicy.getPreferredMemberNodeList() != null) {
 			    nodes = new ArrayList<String>();
 			    policy = "preferred";
 			    for (NodeReference node: replicationPolicy.getPreferredMemberNodeList()) {
 			    	nodes.add(node.getValue());
+			    }
-            leinfelder
+		        this.insertReplicationPolicy(guid, policy, nodes, dbConn);
             leinfelder
+        }
             leinfelder
-            leinfelder
+        // save replica information
-            leinfelder
+        this.insertReplicationStatus(guid, sm.getReplicaList(), dbConn);
             leinfelder
-            leinfelder
+        // save access policy
         AccessPolicy accessPolicy = sm.getAccessPolicy();
         if (accessPolicy != null) {
-            leinfelder
+			this.insertAccessPolicy(guid, accessPolicy);
             leinfelder
             berkley
     /**
-            leinfelder
+     * Creates Metacat access rules and inserts them
      * @param accessPolicy
      * @throws McdbDocNotFoundException
      * @throws AccessException
      */
     private void insertAccessPolicy(String guid, AccessPolicy accessPolicy) throws McdbDocNotFoundException, AccessException {
-            leinfelder
+    	// check for the existing permOrder so that we remain compatible with it (DataONE does not care)
         XMLAccessAccess accessController  = new XMLAccessAccess();
 		String existingPermOrder = AccessControlInterface.ALLOWFIRST;
         Vector<XMLAccessDAO> existingAccess = accessController.getXMLAccessForDoc(guid);
         if (existingAccess != null && existingAccess.size() > 0) {
         	existingPermOrder = existingAccess.get(0).getPermOrder();
+        }
-            leinfelder
+    	List<XMLAccessDAO> accessDAOs = new ArrayList<XMLAccessDAO>();
         for (AccessRule accessRule: accessPolicy.getAllowList()) {
         	List<Subject> subjects = accessRule.getSubjectList();
         	List<Permission> permissions = accessRule.getPermissionList();
         	for (Subject subject: subjects) {
-            leinfelder
+    			XMLAccessDAO accessDAO = new XMLAccessDAO();
         		accessDAO.setPrincipalName(subject.getValue());
     			accessDAO.setGuid(guid);
     			accessDAO.setPermType(AccessControlInterface.ALLOW);
-            leinfelder
+				accessDAO.setPermOrder(existingPermOrder);
     			if (permissions != null) {
 	    			for (Permission permission: permissions) {
 	    				Long metacatPermission = new Long(convertPermission(permission));
 	        			accessDAO.addPermission(metacatPermission);
+	    			}
             leinfelder
     			accessDAOs.add(accessDAO);
             leinfelder
+        }
-            leinfelder
+        // remove all existing allow records
         accessController.deleteXMLAccessForDoc(guid, AccessControlInterface.ALLOW);
         // add the ones we can for this guid
         accessController.insertAccess(guid, accessDAOs);
             leinfelder
             leinfelder
             leinfelder
     /**
      * Lookup access policy from Metacat
      * @param guid
      * @return
      * @throws McdbDocNotFoundException
      * @throws AccessException
      */
-            leinfelder
+    public AccessPolicy getAccessPolicy(String guid) throws McdbDocNotFoundException, AccessException {
-            leinfelder
+        AccessPolicy accessPolicy = new AccessPolicy();
-            leinfelder
+    	// use GUID to look up the access
-            leinfelder
+        XMLAccessAccess accessController  = new XMLAccessAccess();
-            leinfelder
+        List<XMLAccessDAO> accessDAOs = accessController.getXMLAccessForDoc(guid);
-            leinfelder
+        for (XMLAccessDAO accessDAO: accessDAOs) {
-            leinfelder
+        	// only add allow rule
         	if (accessDAO.getPermType().equals(AccessControlInterface.ALLOW)) {
 	        	AccessRule accessRule = new AccessRule();
 	        	List <Permission> permissions = convertPermission(accessDAO.getPermission().intValue());
-            leinfelder
+	        	// cannot include if we have no permissions
 	        	if (permissions == null || permissions.isEmpty()) {
 	        		logMetacat.warn("skipping empty access rule permissions for " + guid);
 	        		continue;
+	        	}
-            leinfelder
+	        	accessRule.setPermissionList(permissions);
 	        	Subject subject = new Subject();
 	        	subject.setValue(accessDAO.getPrincipalName());
 	        	accessRule.addSubject(subject);
 	            accessPolicy.addAllow(accessRule);
+        	}
             leinfelder
         return accessPolicy;
+    }
     public int convertPermission(Permission permission) {
     	if (permission.equals(Permission.READ)) {
     		return AccessControlInterface.READ;
+    	}
     	if (permission.equals(Permission.WRITE)) {
     		return AccessControlInterface.WRITE;
+    	}
     	if (permission.equals(Permission.CHANGE_PERMISSION)) {
     		return AccessControlInterface.CHMOD;
+    	}
 		return -1;
+    }
-            leinfelder
+    public List<Permission> convertPermission(int permission) {
             leinfelder
-            leinfelder
+    	List<Permission> permissions = new ArrayList<Permission>();
-            leinfelder
+    	if (permission == AccessControlInterface.ALL) {
-            leinfelder
+    		permissions.add(Permission.READ);
     		permissions.add(Permission.WRITE);
-            leinfelder
+    		permissions.add(Permission.CHANGE_PERMISSION);
-            leinfelder
+    		return permissions;
             leinfelder
             leinfelder
     	if ((permission & AccessControlInterface.CHMOD) == AccessControlInterface.CHMOD) {
-            leinfelder
+    		permissions.add(Permission.CHANGE_PERMISSION);
             leinfelder
-            leinfelder
+    	if ((permission & AccessControlInterface.READ) == AccessControlInterface.READ) {
-            leinfelder
+    		permissions.add(Permission.READ);
             leinfelder
     	if ((permission & AccessControlInterface.WRITE) == AccessControlInterface.WRITE) {
-            leinfelder
+    		permissions.add(Permission.WRITE);
             leinfelder
             leinfelder
 		return permissions;
             leinfelder
     /**
-            leinfelder
+     * Lookup a localId given the GUID. If
      * the identifier is not found, throw an exception.
+     *
      * @param guid the global identifier to look up
      * @return String containing the corresponding LocalId
      * @throws McdbDocNotFoundException if the identifier is not found
-            berkley
+     */
-            tao
+    public String getLocalId(String guid) throws McdbDocNotFoundException, SQLException {
             berkley
       String db_guid = "";
       String docid = "";
       int rev = 0;
-            leinfelder
+      String query = "select guid, docid, rev from " + TYPE_IDENTIFIER + " where guid = ?";
             berkley
       DBConnection dbConn = null;
-            berkley
+      int serialNumber = -1;
-            berkley
+      try {
           // Get a database connection from the pool
           dbConn = DBConnectionPool.getDBConnection("Identifier.getLocalId");
           serialNumber = dbConn.getCheckOutSerialNumber();
           // Execute the insert statement
           PreparedStatement stmt = dbConn.prepareStatement(query);
           stmt.setString(1, guid);
           ResultSet rs = stmt.executeQuery();
           if (rs.next()) {
               db_guid = rs.getString(1);
               docid = rs.getString(2);
               rev = rs.getInt(3);
               assert(db_guid.equals(guid));
           } else {
               throw new McdbDocNotFoundException("Document not found:" + guid);
+          }
           stmt.close();
       } catch (SQLException e) {
           logMetacat.error("Error while looking up the local identifier: "
                   + e.getMessage());
-            tao
+          throw e;
-            berkley
+      } finally {
           // Return database connection to the pool
           DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+      }
       return docid + "." + rev;
+    }
-            berkley
+    /**
-            berkley
+     * query the systemmetadata table based on the given parameters
      * @param startTime
      * @param endTime
      * @param objectFormat
      * @param replicaStatus
      * @param start
      * @param count
      * @return ObjectList
-            leinfelder
+     * @throws SQLException
      * @throws ServiceException
      * @throws PropertyNotFoundException
-            berkley
+     */
-            cjones
+    public ObjectList querySystemMetadata(Date startTime, Date endTime,
         ObjectFormatIdentifier objectFormatId, boolean replicaStatus,
-            tao
+        int start, int count, Identifier identifier, boolean isSID)
-            cjones
+        throws SQLException, PropertyNotFoundException, ServiceException {
-            berkley
+        ObjectList ol = new ObjectList();
-            berkley
+        DBConnection dbConn = null;
         int serialNumber = -1;
             cjones
-            leinfelder
+        try {
-            leinfelder
+            String fieldSql = "select guid, date_uploaded, rights_holder, checksum, "
-            cjones
+                    + "checksum_algorithm, origin_member_node, authoritive_member_node, "
                     + "date_modified, submitter, object_format, size from systemmetadata";
             leinfelder
             // handle special case quickly
             String countSql = "select count(guid) from systemmetadata";
             leinfelder
             // the clause
             String whereClauseSql = "";
             cjones
-            berkley
+            boolean f1 = false;
             boolean f2 = false;
             boolean f3 = false;
-            tao
+            boolean f4 = false;
             cjones
             tao
-            leinfelder
+            if (startTime != null) {
-            leinfelder
+                whereClauseSql += " where systemmetadata.date_modified >= ?";
-            berkley
+                f1 = true;
+            }
             cjones
-            leinfelder
+            if (endTime != null) {
                 if (!f1) {
-            leinfelder
+                    whereClauseSql += " where systemmetadata.date_modified < ?";
-            cjones
+                } else {
-            leinfelder
+                    whereClauseSql += " and systemmetadata.date_modified < ?";
             berkley
-            berkley
+                f2 = true;
+            }
             cjones
-            leinfelder
+            if (objectFormatId != null) {
-            leinfelder
+                if (!f1 && !f2) {
-            leinfelder
+                    whereClauseSql += " where object_format = ?";
-            cjones
+                } else {
-            leinfelder
+                    whereClauseSql += " and object_format = ?";
             berkley
-            berkley
+                f3 = true;
+            }
             tao
             if(identifier != null && identifier.getValue() != null && !identifier.getValue().equals("")) {
                 if (!f1 && !f2 && !f3 ) {
                     if(isSID) {
                         whereClauseSql += " where series_id = ?";
                     } else {
                         whereClauseSql += " where guid = ?";
+                    }
                 } else {
                     if(isSID) {
                         whereClauseSql += " and series_id = ?";
                     } else {
                         whereClauseSql += " and guid = ?";
+                    }
+                }
                 f4 = true;
+            }
             cjones
-            cjones
+            if (!replicaStatus) {
-            cjones
+                String currentNodeId = PropertyService.getInstance().getProperty("dataone.nodeId");
-            tao
+                if (!f1 && !f2 && !f3 && !f4) {
-            leinfelder
+                    whereClauseSql += " where authoritive_member_node = '" +
-            cjones
+                        currentNodeId.trim() + "'";
                 } else {
-            leinfelder
+                    whereClauseSql += " and authoritive_member_node = '" +
-            cjones
+                        currentNodeId.trim() + "'";
             berkley
             berkley
             leinfelder
             tao
-            leinfelder
+            // connection
-            berkley
+            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.querySystemMetadata");
             serialNumber = dbConn.getCheckOutSerialNumber();
             cjones
-            leinfelder
+            // the field query
             String orderBySql = " order by guid ";
             String fieldQuery = fieldSql + whereClauseSql + orderBySql;
             String finalQuery = DatabaseService.getInstance().getDBAdapter().getPagedQuery(fieldQuery, start, count);
             PreparedStatement fieldStmt = dbConn.prepareStatement(finalQuery);
             // construct the count query and statment
             String countQuery = countSql + whereClauseSql;
             PreparedStatement countStmt = dbConn.prepareStatement(countQuery);
-            tao
+            if (f1 && f2 && f3 && f4) {
-            leinfelder
+                fieldStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 fieldStmt.setTimestamp(2, new Timestamp(endTime.getTime()));
                 fieldStmt.setString(3, objectFormatId.getValue());
-            tao
+                fieldStmt.setString(4, identifier.getValue());
-            leinfelder
+                // count
                 countStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 countStmt.setTimestamp(2, new Timestamp(endTime.getTime()));
                 countStmt.setString(3, objectFormatId.getValue());
-            tao
+                countStmt.setString(4, identifier.getValue());
             } if (f1 && f2 && f3 && !f4) {
-            leinfelder
+                fieldStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 fieldStmt.setTimestamp(2, new Timestamp(endTime.getTime()));
-            tao
+                fieldStmt.setString(3, objectFormatId.getValue());
-            leinfelder
+                // count
                 countStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 countStmt.setTimestamp(2, new Timestamp(endTime.getTime()));
-            tao
+                countStmt.setString(3, objectFormatId.getValue());
             } else if (f1 && f2 && !f3 && f4) {
-            leinfelder
+                fieldStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
-            tao
+                fieldStmt.setTimestamp(2, new Timestamp(endTime.getTime()));
                 fieldStmt.setString(3, identifier.getValue());
                 // count
                 countStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 countStmt.setTimestamp(2, new Timestamp(endTime.getTime()));
                 countStmt.setString(3, identifier.getValue());
             } else if (f1 && f2 && !f3 && !f4) {
                 fieldStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 fieldStmt.setTimestamp(2, new Timestamp(endTime.getTime()));
                 // count
                 countStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 countStmt.setTimestamp(2, new Timestamp(endTime.getTime()));
             } else if (f1 && !f2 && f3 && f4) {
                 fieldStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
-            leinfelder
+                fieldStmt.setString(2, objectFormatId.getValue());
-            tao
+                fieldStmt.setString(3, identifier.getValue());
-            leinfelder
+                // count
                 countStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 countStmt.setString(2, objectFormatId.getValue());
-            tao
+                countStmt.setString(3, identifier.getValue());
             } else if (f1 && !f2 && f3 && !f4) {
-            leinfelder
+                fieldStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
-            tao
+                fieldStmt.setString(2, objectFormatId.getValue());
-            leinfelder
+                // count
                 countStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
-            tao
+                countStmt.setString(2, objectFormatId.getValue());
             } else if (f1 && !f2 && !f3 && f4) {
                 fieldStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 fieldStmt.setString(2, identifier.getValue());
                 // count
                 countStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 countStmt.setString(2, identifier.getValue());
             } else if (f1 && !f2 && !f3 && !f4) {
                 fieldStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 // count
                 countStmt.setTimestamp(1, new Timestamp(startTime.getTime()));
             } else if (!f1 && f2 && f3 && f4) {
-            leinfelder
+                fieldStmt.setTimestamp(1, new Timestamp(endTime.getTime()));
                 fieldStmt.setString(2, objectFormatId.getValue());
-            tao
+                fieldStmt.setString(3, identifier.getValue());
-            leinfelder
+                // count
                 countStmt.setTimestamp(1, new Timestamp(endTime.getTime()));
                 countStmt.setString(2, objectFormatId.getValue());
-            tao
+                countStmt.setString(3, identifier.getValue());
             } else if (!f1 && f2 && f3 && !f4) {
                 fieldStmt.setTimestamp(1, new Timestamp(endTime.getTime()));
                 fieldStmt.setString(2, objectFormatId.getValue());
                 // count
                 countStmt.setTimestamp(1, new Timestamp(endTime.getTime()));
                 countStmt.setString(2, objectFormatId.getValue());
             } else if (!f1 && !f2 && f3 && f4) {
-            leinfelder
+                fieldStmt.setString(1, objectFormatId.getValue());
-            tao
+                fieldStmt.setString(2, identifier.getValue());
-            leinfelder
+                // count
                 countStmt.setString(1, objectFormatId.getValue());
-            tao
+                countStmt.setString(2, identifier.getValue());
             } else if (!f1 && !f2 && f3 && !f4) {
                 fieldStmt.setString(1, objectFormatId.getValue());
                 // count
                 countStmt.setString(1, objectFormatId.getValue());
             } else if (!f1 && f2 && !f3 && f4) {
-            leinfelder
+                fieldStmt.setTimestamp(1, new Timestamp(endTime.getTime()));
-            tao
+                fieldStmt.setString(2, identifier.getValue());
-            leinfelder
+                // count
                 countStmt.setTimestamp(1, new Timestamp(endTime.getTime()));
-            tao
+                countStmt.setString(2, identifier.getValue());
             } else if (!f1 && f2 && !f3 && !f4) {
                 fieldStmt.setTimestamp(1, new Timestamp(endTime.getTime()));
                 // count
                 countStmt.setTimestamp(1, new Timestamp(endTime.getTime()));
             } else if (!f1 && !f2 && !f3 && f4) {
                 fieldStmt.setString(1, identifier.getValue());
                 // count
                 countStmt.setString(1, identifier.getValue());
             } else if (!f1 && !f2 && !f3 && !f4) {
                 //do nothing
             berkley
             cjones
-            leinfelder
+            logMetacat.debug("list objects fieldStmt: " + fieldStmt.toString());
             logMetacat.debug("list objects countStmt: " + countStmt.toString());
-            leinfelder
+            // get the total object count no matter what
             int total = 0;
             ResultSet totalResult = countStmt.executeQuery();
             if (totalResult.next()) {
             	total = totalResult.getInt(1);
             berkley
             leinfelder
-            leinfelder
+            logMetacat.debug("list objects total: " + total);
-            leinfelder
+        	// set the totals
         	ol.setStart(start);
             ol.setCount(count);
             ol.setTotal(total);
             // retrieve the actual records if requested
             if (count != 0) {
                 ResultSet rs = fieldStmt.executeQuery();
-            leinfelder
+	            while (rs.next()) {
             leinfelder
-            leinfelder
+	                String guid = rs.getString(1);
-            leinfelder
+	                logMetacat.debug("query found object with guid " + guid);
-            leinfelder
+	                // Timestamp dateUploaded = rs.getTimestamp(2);
 	                // String rightsHolder = rs.getString(3);
 	                String checksum = rs.getString(4);
 	                String checksumAlgorithm = rs.getString(5);
 	                // String originMemberNode = rs.getString(6);
 	                // String authoritiveMemberNode = rs.getString(7);
 	                Timestamp dateModified = rs.getTimestamp(8);
 	                // String submitter = rs.getString(9);
 	                String fmtidStr = rs.getString(10);
 	                String sz = rs.getString(11);
 	                BigInteger size = new BigInteger("0");
 	                if (sz != null && !sz.trim().equals("")) {
 	                    size = new BigInteger(rs.getString(11));
+	                }
 	                ObjectInfo oi = new ObjectInfo();
 	                Identifier id = new Identifier();
 	                id.setValue(guid);
 	                oi.setIdentifier(id);
 	                if (dateModified != null) {
 	                    oi.setDateSysMetadataModified(dateModified);
+	                }
 	                Checksum cs = new Checksum();
 	                cs.setValue(checksum);
 	                try {
 	                    // cs.setAlgorithm(ChecksumAlgorithm.valueOf(checksumAlgorithm));
 	                    cs.setAlgorithm(checksumAlgorithm);
 	                } catch (Exception e) {
 	                    logMetacat.error("could not parse checksum algorithm", e);
 	                    continue;
+	                }
 	                oi.setChecksum(cs);
 	                // set the format type
 	                ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();
 	                fmtid.setValue(fmtidStr);
 	                oi.setFormatId(fmtid);
 	                oi.setSize(size);
-            leinfelder
+	                ol.addObjectInfo(oi);
             leinfelder
             leinfelder
-            leinfelder
+	            logMetacat.debug("list objects count: " + ol.sizeObjectInfoList());
-            leinfelder
+	            // set the actual count retrieved
 	            ol.setCount(ol.sizeObjectInfoList());
             leinfelder
+	        }
             berkley
             cjones
-            leinfelder
+        finally {
-            berkley
+            // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
             cjones
-            berkley
+        return ol;
+    }
     /**
-            leinfelder
+     * create a mapping in the identifier table
-            berkley
+     * @param guid
      * @param localId
      */
-            leinfelder
+    public void createMapping(String guid, String localId)
             berkley
             berkley
         int serialNumber = -1;
-            berkley
+        DBConnection dbConn = null;
         try {
             // Parse the localId into scope and rev parts
             AccessionNumber acc = new AccessionNumber(localId, "NOACTION");
             String docid = acc.getDocid();
-            berkley
+            int rev = 1;
-            leinfelder
+            if (acc.getRev() != null) {
-            berkley
+              rev = (new Integer(acc.getRev()).intValue());
+            }
             berkley
             // Get a database connection from the pool
-            leinfelder
+            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.createMapping");
-            berkley
+            serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
-            leinfelder
+            String query = "insert into " + TYPE_IDENTIFIER + " (guid, docid, rev) values (?, ?, ?)";
-            berkley
+            PreparedStatement stmt = dbConn.prepareStatement(query);
             stmt.setString(1, guid);
             stmt.setString(2, docid);
             stmt.setInt(3, rev);
-            leinfelder
+            logMetacat.debug("mapping query: " + stmt.toString());
-            berkley
+            int rows = stmt.executeUpdate();
             stmt.close();
         } catch (SQLException e) {
-            berkley
+            e.printStackTrace();
-            leinfelder
+            logMetacat.error("createGenericMapping: SQL error while creating a mapping to the " + TYPE_IDENTIFIER + " identifier: "
-            berkley
+                    + e.getMessage());
         } catch (NumberFormatException e) {
-            berkley
+            e.printStackTrace();
-            leinfelder
+            logMetacat.error("createGenericMapping: NumberFormat error while creating a mapping to the " + TYPE_IDENTIFIER + " identifier: "
-            berkley
+                    + e.getMessage());
         } catch (AccessionNumberException e) {
-            berkley
+            e.printStackTrace();
-            leinfelder
+            logMetacat.error("createGenericMapping: AccessionNumber error while creating a mapping to the " + TYPE_IDENTIFIER + " identifier: "
-            berkley
+                    + e.getMessage());
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
+    }
             leinfelder
     /**
-            leinfelder
+     * remove a mapping in the identifier table
      * @param guid
      * @param localId
      */
     public void removeMapping(String guid, String localId)
+    {
         int serialNumber = -1;
         DBConnection dbConn = null;
         try {
             // Parse the localId into scope and rev parts
             AccessionNumber acc = new AccessionNumber(localId, "NOACTION");
             String docid = acc.getDocid();
             int rev = 1;
             if (acc.getRev() != null) {
               rev = (new Integer(acc.getRev()).intValue());
+            }
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.removeMapping");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             String query = "DELETE FROM " + TYPE_IDENTIFIER + " WHERE guid = ? AND docid = ? AND rev = ?";
             PreparedStatement stmt = dbConn.prepareStatement(query);
             stmt.setString(1, guid);
             stmt.setString(2, docid);
             stmt.setInt(3, rev);
             logMetacat.debug("remove mapping query: " + stmt.toString());
             int rows = stmt.executeUpdate();
             stmt.close();
         } catch (SQLException e) {
             e.printStackTrace();
             logMetacat.error("removeMapping: SQL error while removing a mapping to the " + TYPE_IDENTIFIER + " identifier: "
                     + e.getMessage());
         } catch (NumberFormatException e) {
             e.printStackTrace();
             logMetacat.error("removeMapping: NumberFormat error while removing a mapping to the " + TYPE_IDENTIFIER + " identifier: "
                     + e.getMessage());
         } catch (AccessionNumberException e) {
             e.printStackTrace();
             logMetacat.error("removeMapping: AccessionNumber error while removing a mapping to the " + TYPE_IDENTIFIER + " identifier: "
                     + e.getMessage());
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
+    }
     /**
-            leinfelder
+     * create the systemmetadata record
      * @param guid
-            leinfelder
+     * @param dbConn
      * @throws SQLException
-            leinfelder
+     */
-            leinfelder
+    private void insertSystemMetadata(String guid, DBConnection dbConn) throws SQLException
             leinfelder
-            leinfelder
+        // Execute the insert statement
         String query = "insert into " + TYPE_SYSTEM_METADATA + " (guid) values (?)";
         PreparedStatement stmt = dbConn.prepareStatement(query);
         stmt.setString(1, guid);
         logMetacat.debug("system metadata query: " + stmt.toString());
         int rows = stmt.executeUpdate();
             leinfelder
-            leinfelder
+        stmt.close();
             leinfelder
             leinfelder
-            tao
+    public boolean deleteSystemMetadata(String guid)
             leinfelder
-            tao
+        boolean success = false;
-            leinfelder
+        int serialNumber = -1;
         DBConnection dbConn = null;
-            leinfelder
+        String query = null;
         PreparedStatement stmt = null;
         int rows = 0;
-            leinfelder
+        try {
-            tao
+        	 // Get a database connection from the pool
-            leinfelder
+            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.deleteSystemMetadata");
-            leinfelder
+            serialNumber = dbConn.getCheckOutSerialNumber();
-            tao
+            dbConn.setAutoCommit(false);
-            leinfelder
+            // remove the smReplicationPolicy
             query = "delete from smReplicationPolicy " +
-            leinfelder
+            "where guid = ?";
             stmt = dbConn.prepareStatement(query);
             stmt.setString(1, guid);
-            leinfelder
+            logMetacat.debug("delete smReplicationPolicy: " + stmt.toString());
-            leinfelder
+            rows = stmt.executeUpdate();
             stmt.close();
-            leinfelder
+            // remove the smReplicationStatus
             query = "delete from smReplicationStatus " +
-            leinfelder
+            "where guid = ?";
             stmt = dbConn.prepareStatement(query);
             stmt.setString(1, guid);
-            leinfelder
+            logMetacat.debug("delete smReplicationStatus: " + stmt.toString());
-            leinfelder
+            rows = stmt.executeUpdate();
             stmt.close();
-            tao
+            // remove main system metadata entry
             query = "delete from " + TYPE_SYSTEM_METADATA + " where guid = ? ";
             stmt = dbConn.prepareStatement(query);
             stmt.setString(1, guid);
             logMetacat.debug("delete system metadata: " + stmt.toString());
             rows = stmt.executeUpdate();
             stmt.close();
             dbConn.commit();
             dbConn.setAutoCommit(true);
             success = true;
-            leinfelder
+            // TODO: remove the access?
-            leinfelder
+            // Metacat keeps "deleted" documents so we should not remove access rules.
-            leinfelder
+        } catch (Exception e) {
             e.printStackTrace();
             logMetacat.error("Error while deleting " + TYPE_SYSTEM_METADATA + " record: " + guid, e );
-            leinfelder
+            try {
 				dbConn.rollback();
 			} catch (SQLException sqle) {
 	            logMetacat.error("Error while rolling back delete for record: " + guid, sqle );
+			}
-            leinfelder
+        } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
-            tao
+        return success;
             leinfelder
             leinfelder
     public void updateAuthoritativeMemberNodeId(String existingMemberNodeId, String newMemberNodeId)
+    {
         DBConnection dbConn = null;
         int serialNumber = -1;
         try {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.updateAuthoritativeMemberNodeId");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             String query = "update " + TYPE_SYSTEM_METADATA +
                 " set authoritive_member_node = ? " +
                 " where authoritive_member_node = ?";
             PreparedStatement stmt = dbConn.prepareStatement(query);
             //data values
             stmt.setString(1, newMemberNodeId);
             stmt.setString(2, existingMemberNodeId);
             logMetacat.debug("stmt: " + stmt.toString());
             //execute
             int rows = stmt.executeUpdate();
             stmt.close();
         } catch (SQLException e) {
             e.printStackTrace();
             logMetacat.error("updateSystemMetadataFields: SQL error while updating system metadata: "
                     + e.getMessage());
         } catch (NumberFormatException e) {
             e.printStackTrace();
             logMetacat.error("updateSystemMetadataFields: NumberFormat error while updating system metadata: "
                     + e.getMessage());
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
+    }
             jones

Project

General

Profile

Metacat