Metacat

    /*

     * Inserts or updates system metadata documents in Metacat. Note: This

     * needs to be refactored out of MetacatHandler and into a utitlity when 

     * stream i/o in Metacat is evaluated.

     *

     * @param params  A hash table of parameters

     * @param user  The username doing the document insert or update

     * @param groups  The groups the user belongs in

     *

     * @return localId  The new docid of the inserted or updated document

     *

     * @throws SQLException

     */

    private String insertOrUpdateSystemMetadata(

      Hashtable<String, String[]> params, String user, String[] groups)

      throws SQLException, McdbException, InsufficientKarmaException {

      DocumentImplWrapper docImpl = new DocumentImplWrapper("", false);

      DBConnection dbConn         = null;

      int serialNumber            = -1;

      String qformat              = "xml";

      String[] doctext            = null;

      String xml                  = null;

      String doc                  = null;

      String[] action             = null;

      String doAction             = null;

      String[] docid              = null;

      String accNumber            = null;

      String newAccNumber         = null;

      String pub                  = null;

      StringReader dtd            = null;

      // ensure we have a an accession number

      if ( params.get("docid") == null ) {

        throw new McdbException("The docid parameter was not set.");

      } else {

        accNumber = docid[0];

      }

      // ensure we have an action

      if ( params.get("action") == null ) {

        throw new McdbException("The action parameter was not set.");

      } else {

        if ( action[0].equals("insert") ) {

            doAction = "INSERT";

        } else if (action[0].equals("update")) {

            doAction = "UPDATE";

        }

      }

      // ensure we have the document text

      if ( params.get("doctext") == null ) {

        throw new McdbException("The doctext parameter was not set.");

      } else {

        doctext = params.get("doctext");

        xml = doctext[0];

      }

      // ensure user can insert or update      

      try {

        if ( !(AuthUtil.canInsertOrUpdate(user, groups)) ) {

          throw new InsufficientKarmaException("The user " + user +

            "does not have permission to insert or update system metadata.");

        }

      } catch (MetacatUtilException ue) {

        throw new InsufficientKarmaException("Couldn't determine if user " + user +

          "has permission to insert or update system metadata.");

      }

      try {

        // get a database connection from the pool

        dbConn = 

        DBConnectionPool.getDBConnection(

          "MetacatHandler.insertOrUpdateSystemMetadata");

        serialNumber = dbConn.getCheckOutSerialNumber();

        // write the document to the database and disk

        logMetacat.debug("MetacatHandler.insertOrUpdateSystemMetadata(): " +

          "Begin writing XML to Metacat for " + doAction + 

          " operation.");

        // write the system metadata document

        newAccNumber = docImpl.write(dbConn, xml, pub, dtd, 

                                     doAction, accNumber, user, groups);

        logMetacat.debug("MetacatHandler.insertOrUpdateSystemMetadata(): " +

          "Wrote XML to Metacat for " + doAction + 

          " operation.");

      // unfortunately DocumentImplWrapper only raises a general exception  

      } catch (Exception e ) {

          throw new McdbException(e.getMessage());

      } finally {

        // Return db connection

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }

      return newAccNumber;

    }

     * Get the system metadata for a document with a specified guid

     *

     * @param guid  The identifier used to look up system metadata

     *

     * @return sysMeta  The desired SystemMetadata object

     */

     public SystemMetadata getSystemMetadata(Identifier guid) 

      throws NotFound {

      SystemMetadata sysMeta = new SystemMetadata();

      return sysMeta;

    }

    /*

     * Update a system metadata document with new values

     * 

     * @param sysMeta  The new system metadata object

     * @param user  The user submitting the system metadata document

     * @param groups  The groups the user belongs to

     */

    private void updateSystemMetadata(SystemMetadata sysMeta,

      String user, String[] groups) {

      logMetacat.debug("MetacatHandler.updateSystemMetadata() called.");

      String localId = null;

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

      params.put("action", new String[]{"update"});

      try {

        String smId = IdentifierManager.getInstance().getSystemMetadataLocalId(

          sysMeta.getIdentifier().getValue());

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

      } catch ( McdbDocNotFoundException mdnfe ) {

        logMetacat.debug("There was a problem getting the system " +

        "metadata local id. The error was: " + mdnfe.getMessage());

        params.put("docid", null);

      }

      logMetacat.debug("Setting date modified to " + new Date());

      // set the date_updated date

      sysMeta.setDateSysMetadataModified(new Date());

      // update the XML document in Metacat

      try {

        String xml = new String(serializeSystemMetadata(sysMeta).toByteArray());

        params.put("doctext", new String[]{xml});

      } catch ( JiBXException jxe ) {

        logMetacat.debug("There was a problem serializing the system " +

        "metadata document. The error was: " + jxe.getMessage());

        params.put("doctext", null);

      }

      try {

        localId = insertOrUpdateSystemMetadata(params, user, groups);

      } catch ( SQLException sqle ) {

        logMetacat.debug("There was a problem writing the system metadata " +

          "document to Metacat. The error message was: " + sqle.getMessage());

      } catch ( McdbException me ) {

        logMetacat.debug("There was a problem writing the system metadata " +

          "document to Metacat. The error message was: " + me.getMessage());

      } catch ( InsufficientKarmaException ike ) {

        logMetacat.debug("There was a permission problem writing the system metadata " +

          "document to Metacat. The error message was: " + ike.getMessage());

      }

      // update the identifier mapping

      IdentifierManager.getInstance().updateSystemMetadataMapping(

        sysMeta.getIdentifier().getValue(), localId);

      // update the system metadata table

      IdentifierManager.getInstance().insertAdditionalSystemMetadataFields(

        sysMeta.getDateUploaded().getTime(), 

        sysMeta.getRightsHolder().getValue(),

        sysMeta.getChecksum().getValue(), 

        /*sysMeta.getChecksum().getAlgorithm().toString()*/

        sysMeta.getChecksum().getAlgorithm().name(), 

        sysMeta.getOriginMemberNode().getValue(), 

        sysMeta.getAuthoritativeMemberNode().getValue(), 

        sysMeta.getDateSysMetadataModified().getTime(), 

        sysMeta.getSubmitter().getValue(), 

        sysMeta.getIdentifier().getValue(), 

        sysMeta.getObjectFormat().toString(), 

        sysMeta.getSize());

    }

    /**