Metacat

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.security.NoSuchAlgorithmException;

import java.sql.SQLException;

import java.text.DateFormat;

import java.util.Calendar;

import java.util.Date;

import java.util.Enumeration;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.io.IOUtils;

import org.apache.log4j.Logger;

import org.dataone.service.exceptions.BaseException;

import org.dataone.service.exceptions.IdentifierNotUnique;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.exceptions.UnsupportedType;

import org.dataone.service.mn.MemberNodeCrud;

import org.dataone.service.types.AuthToken;

import org.dataone.service.types.Checksum;

import org.dataone.service.types.ChecksumAlgorithm;

import org.dataone.service.types.Principal;

import org.dataone.service.types.SystemMetadata;

import org.dataone.service.types.util.ServiceTypeUtil;

import org.jibx.runtime.BindingDirectory;

import org.jibx.runtime.IBindingFactory;

import org.jibx.runtime.IMarshallingContext;

import org.jibx.runtime.IUnmarshallingContext;

import org.jibx.runtime.JiBXException;

import edu.ucsb.nceas.metacat.AccessionNumber;

import edu.ucsb.nceas.metacat.AccessionNumberException;

import edu.ucsb.nceas.metacat.DocumentImpl;

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

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

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

import edu.ucsb.nceas.utilities.ParseLSIDException;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

     * @param localId the identifier of the object to be processed

     */

    public void generateMissingSystemMetadata(AuthToken token, String localId) {

        try {

            //generate required system metadata fields from the document

            SystemMetadata sm = createSystemMetadata(localId, token);

            //insert the systemmetadata object

            SessionData sessionData = getSessionData(token);

            String smlocalid = insertSystemMetadata(sm, sessionData);

            handler.setAccess(metacatUrl, sessionData.getUserName(), smlocalid, "public", "4", "allow", "allowFirst");

            String username = "public";

            EventLog.getInstance().log(metacatUrl, username, localId, "generateMissingSystemMetadata");

        } catch (Exception e) { // TODO: Please don't catch Exception -- it masks bad things

            e.printStackTrace();

            logMetacat.error("Could not generate missing system metadata: " + e.getMessage());

        }

        logCrud.info("generateMissingSystemMetadata(token, localId)");

        if (isScienceMetadata) {

            // CASE METADATA:

            try {

                this.insertDocument(object, guid, sessionData);

                localId = im.getLocalId(guid.getValue());

            } catch (IOException e) {

        // For Metadata and Data, insert the system metadata into the object store too

        String sysMetaLocalId = insertSystemMetadata(sysmeta, sessionData);

        //get the document info.  add any access params for the sysmeta too

        //    "metadata who's parent doc's  local id is " + localId);

        try

        {

                String permissionType = (String)ah.get("permission_type");

                String permissionOrder = (String)ah.get("permission_order");

                int perm = new Integer(permission).intValue();

                //    " perm_order: " + permissionOrder);

                this.setAccess(token, guid, principal, perm, permissionType, permissionOrder, true);

            }

        {

            perm = "write";

        }

        setAccess(token, id, principal, perm, permissionType, permissionOrder,

                setSystemMetadata);

            {

                permNum = "6";

            }

                    " is setting access level " + permNum + " for permission " + 

                    permissionType + " on doc with localid " + docid);

            handler.setAccess(metacatUrl, sessionData.getUserName(), docid, 

            {

                //set the same perms on the system metadata doc

                String smlocalid = im.getSystemMetadataLocalId(id.getValue());

                //cs.setAccess(token, smid, principal, permission, permissionType, permissionOrder);

                handler.setAccess(metacatUrl, sessionData.getUserName(), smlocalid,

                        principal, permNum, permissionType, permissionOrder);

        Identifier sysMetaGuid = new Identifier();

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

        sysmeta.setDateSysMetadataModified(new Date());

                sysmeta.getDateSysMetadataModified());

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

        String localId = insertDocument(xml, sysMetaGuid, sessionData, true);

        //insert the system metadata doc id into the systemmetadata table to 

        //link it to the data or metadata document

        IdentifierManager.getInstance().createSystemMetadataMapping(

    private void updateSystemMetadata(SystemMetadata sm, SessionData sessionData)

      throws ServiceFailure

    {

        try

        {

            String smId = IdentifierManager.getInstance().getSystemMetadataLocalId(sm.getIdentifier().getValue());

            sm.setDateSysMetadataModified(new Date());

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

            String localId = updateDocument(xml, sm.getIdentifier(), null, sessionData, true);

            IdentifierManager.getInstance().updateSystemMetadataMapping(sm.getIdentifier().getValue(), localId);

        }

        catch(Exception e)

        {

            //localid should already exist in the identifier table, so just find it

            try

            {

                if(!isSystemMetadata)

                {

                    localId = im.getLocalId(guid.getValue());

                }

                else

                {

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

                }

                //increment the revision

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

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

                rev++;

                docid = docid + "." + rev;

                localId = docid;

            }

            catch(McdbDocNotFoundException e)

            {

        c.set(new Integer(year).intValue(), 

              new Integer(month).intValue(), 

              new Integer(day).intValue());

        return c.getTime();

    }

        throws McdbDocNotFoundException, NumberFormatException, AccessionNumberException, 

        SQLException, NoSuchAlgorithmException, IOException, PropertyNotFoundException, BaseException {

        IdentifierManager im = IdentifierManager.getInstance();

        Hashtable<String, Object> docInfo = im.getDocumentInfo(localId);

        Identifier identifier = new Identifier();

        try {

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

        } catch (McdbDocNotFoundException mcdbe) { 

            //we're creating a new SM doc for a doc that is not in the identifier table                                       

            //so we need to add it to

            im.createMapping(localId, localId);

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

            identifier.setValue(im.getGUID(accNum.getDocid(), rev));

        }

        InputStream is = this.get(token, identifier);

        SystemMetadata sm = new SystemMetadata();

        //set the id

        sm.setIdentifier(identifier);

        String doctype = (String) docInfo.get("doctype");

        if (format == null) {

            if (doctype.trim().equals("BIN")) {

                format = ObjectFormat.OCTET_STREAM;

            }

        }

        sm.setObjectFormat(format);

        //create the checksum

        String checksumS = checksum(is);

        ChecksumAlgorithm ca = ChecksumAlgorithm.convert("MD5");

        Checksum checksum = new Checksum();

            Date dateUpdated = parseMetacatDate((String) docInfo.get("date_updated"));

            sm.setDateSysMetadataModified(dateUpdated);

        } catch (Exception e) {

            Date dateCreated = new Date();

            sm.setDateUploaded(dateCreated);

            Date dateUpdated = new Date();