Metacat

import org.jibx.runtime.IUnmarshallingContext;

import org.dataone.service.types.AuthToken;

                  sysMeta = getSystemMetadata(identifier, user, groups);

                  sysMetaLocalId = insertOrUpdateSystemMetadata(

                    sysMeta, "update", user, groups);

                } catch ( PropertyNotFoundException pnfe) {

                  logMetacat.error("There was a problem getting the server " +

                    "url properties: " + pnfe.getMessage());

                    sysMetaLocalId = insertOrUpdateSystemMetadata(

                      sysMeta, "insert", user, groups);

     * Serialize a system metadata doc. Note: This needs to refactored out

     * of MetacatHandler and into a utitlity when stream i/o in Metacat is

     * evaluated.

     *

     * @param sysmeta  The system metadata object to be serialized

     * @return sysMetaOut  The system metadata XML document as a ByteArrayOutputStream

     * @throws JiBXException

     */

    private static ByteArrayOutputStream serializeSystemMetadata(SystemMetadata sysmeta) 

      throws JiBXException {

      IBindingFactory bfact;

      ByteArrayOutputStream sysmetaOut = null;

      try {

          bfact = BindingDirectory.getFactory(SystemMetadata.class);

          IMarshallingContext mctx = bfact.createMarshallingContext();

          sysmetaOut = new ByteArrayOutputStream();

          mctx.marshalDocument(sysmeta, "UTF-8", null, sysmetaOut);

      } catch (JiBXException jxe) {

        throw jxe;

      }

      return sysmetaOut;

    }

    /**

        identifier.setValue(im.getGUID(localId, rev));

        AccessionNumber accNum = new AccessionNumber(localId, "NONE");

	logMetacat.debug("accessionNumber: " + accNum);

                dataSysMeta = this.getSystemMetadata(dataDocId, username, groups);

                dataSysMetaId = insertOrUpdateSystemMetadata(

                  dataSysMeta, "update", username, groups);

                  dataSysMetaId = insertOrUpdateSystemMetadata(

                    dataSysMeta, "insert", username, groups);

              } catch ( InsufficientKarmaException ike ) {

                logMetacat.debug("There was an access problem reading " +

                  localId + ". The error message was: " + ike.getMessage());

                throw ike;

              } catch ( JiBXException jxe ) {

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

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

                throw jxe;

    /*

     * 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 sysMeta The system metadata object to process

     * @param action  The action to perform, insert or update

     * @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(SystemMetadata sysMeta,

      String action, String user, String[] groups) 

      throws SQLException, InsufficientKarmaException, JiBXException,

      PropertyNotFoundException, McdbException, McdbDocNotFoundException {

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

      String metacatUrl = "";

      action = action.toUpperCase();

      try {

        String server  = PropertyService.getProperty("server.name");

        String port    = PropertyService.getProperty("server.httpPort");

        String context = PropertyService.getProperty("application.context");

        metacatUrl     = "http://" + server + ":" + port + "/" + context;

      } catch ( PropertyNotFoundException pnfe ) {

        logMetacat.error("Couldn't get the server url properties: " +

          pnfe.getMessage());

          throw pnfe;

      }

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

      DBConnection dbConn         = null;

      int serialNumber            = -1;

      String qformat              = "xml";

      String xml                  = null;

      String doc                  = null;

      String localId              = null;

      String newAccNumber         = null;

      String pub                  = null;

      StringReader dtd            = null;

      IdentifierManager im = IdentifierManager.getInstance();

      Identifier sysMetaGuid = new Identifier();

      sysMetaGuid.setValue(DocumentUtil.generateDocumentId(1));

      sysMeta.setDateSysMetadataModified(new Date());

      // either generate or get a system metadata localId

      try {

        if ( action.equals("INSERT") ) {

          localId = im.generateLocalId(sysMetaGuid.getValue(), 1, true);

        } else if ( action.equals("UPDATE") ) {

          localId = im.getSystemMetadataLocalId(sysMetaGuid.getValue());

          String docid = localId.substring(0, localId.lastIndexOf("."));

          String revString = 

            localId.substring(localId.lastIndexOf(".") + 1, localId.length());

          int rev = new Integer(revString).intValue();

          rev++;

          docid = docid + "." + rev;

          localId = docid;

          logMetacat.debug("Incremented system metadata localId: " + localId);

        }

      } catch ( McdbDocNotFoundException mnfe ) {

        throw mnfe;

      }

      // get the xml from the sytem metadata object

      try {

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

      } catch ( JiBXException jxe ) {

        throw jxe;

      }

      logMetacat.debug("SystemMetadata to insert or update: " + xml);

      // 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 " + action + 

          " operation.");

        // write the system metadata document

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

                                     action, localId, user, groups);

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

          "Wrote XML to Metacat for " + action + 

          " operation.");

        if ( action.equals("INSERT") ) {

          IdentifierManager.getInstance().createSystemMetadataMapping(

                  sysMeta, sysMetaGuid.getValue());

          setAccess(metacatUrl, user, newAccNumber, 

                    "public", "4", "allow", "allowFirst");

        } else if ( action.equals("UPDATE") ) {

          IdentifierManager.getInstance().updateSystemMetadataMapping(

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

          IdentifierManager.getInstance().insertAdditionalSystemMetadataFields(

            sysMeta.getDateUploaded().getTime(), 

            sysMeta.getRightsHolder().getValue(),

            sysMeta.getChecksum().getValue(), 

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

            sysMeta.getOriginMemberNode().getValue(), 

            sysMeta.getAuthoritativeMemberNode().getValue(), 

            sysMeta.getDateSysMetadataModified().getTime(), 

            sysMeta.getSubmitter().getValue(), 

            sysMeta.getIdentifier().getValue(), 

            sysMeta.getObjectFormat().toString(), 

            sysMeta.getSize());

        }

      // 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;

    }

    private SystemMetadata getSystemMetadata(Identifier guid, 

      String user, String[] groups) 

      throws McdbDocNotFoundException, InsufficientKarmaException, 

      JiBXException, ParseLSIDException, PropertyNotFoundException,

      McdbException, SQLException, IOException, ClassNotFoundException {

      SystemMetadata sysMeta = new SystemMetadata();

      InputStream inputStream;

        IdentifierManager im = IdentifierManager.getInstance();

        String localId = im.getSystemMetadataLocalId(guid.getValue());

        try {

          inputStream = this.read(localId);

        } catch ( McdbDocNotFoundException dnfe ) {

          throw dnfe;

        } catch ( ParseLSIDException ple ) {

          throw ple;

        } catch ( PropertyNotFoundException pnfe ) {

          throw pnfe;

        } catch ( McdbException me ) {

          throw me;

        } catch ( SQLException sqle ) {

          throw sqle;

        } catch ( ClassNotFoundException cnfe ) {

          throw cnfe;

        } catch ( IOException ioe ) {

          throw ioe;

        } // end try()

        try {

          sysMeta = deserializeSystemMetadata(inputStream);

          return sysMeta;

        } catch ( JiBXException jxe ) {

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

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

          throw jxe;

        }

    /**

     * deserialize a system metadata doc. Note: This needs to refactored out

     * of MetacatHandler and into a utitlity when stream i/o in Metacat is

     * evaluated.

     * @param xml  The xml to be deserialized

     * @return sysmeta  The SystemMetadata object to be returned

     * @throws JiBXException

     */

    private static SystemMetadata deserializeSystemMetadata(InputStream xml) 

      throws JiBXException {

      try {

          IBindingFactory bfact = 

            BindingDirectory.getFactory(SystemMetadata.class);

          IUnmarshallingContext uctx = bfact.createUnmarshallingContext();

          SystemMetadata sysmeta = 

            (SystemMetadata) uctx.unmarshalDocument(xml, null);

          return sysmeta;

      } catch (JiBXException jxe) {

        throw jxe;

      }

    }