Java tutorial
/** * The contents of this file are subject to the license and copyright * detailed in the LICENSE and NOTICE files at the root of the source * tree and available online at * * http://www.dspace.org/license/ */ package org.dspace.content.packager; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.sql.SQLException; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.commons.compress.archivers.zip.ZipArchiveEntry; import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream; import edu.harvard.hul.ois.mets.AmdSec; import edu.harvard.hul.ois.mets.BinData; import edu.harvard.hul.ois.mets.Checksumtype; import edu.harvard.hul.ois.mets.Div; import edu.harvard.hul.ois.mets.DmdSec; import edu.harvard.hul.ois.mets.MdRef; import edu.harvard.hul.ois.mets.FLocat; import edu.harvard.hul.ois.mets.FileGrp; import edu.harvard.hul.ois.mets.FileSec; import edu.harvard.hul.ois.mets.Fptr; import edu.harvard.hul.ois.mets.Mptr; import edu.harvard.hul.ois.mets.Loctype; import edu.harvard.hul.ois.mets.MdWrap; import edu.harvard.hul.ois.mets.Mdtype; import edu.harvard.hul.ois.mets.Mets; import edu.harvard.hul.ois.mets.MetsHdr; import edu.harvard.hul.ois.mets.StructMap; import edu.harvard.hul.ois.mets.TechMD; import edu.harvard.hul.ois.mets.SourceMD; import edu.harvard.hul.ois.mets.DigiprovMD; import edu.harvard.hul.ois.mets.RightsMD; import edu.harvard.hul.ois.mets.helper.MdSec; import edu.harvard.hul.ois.mets.XmlData; import edu.harvard.hul.ois.mets.helper.Base64; import edu.harvard.hul.ois.mets.helper.MetsElement; import edu.harvard.hul.ois.mets.helper.MetsException; import edu.harvard.hul.ois.mets.helper.MetsValidator; import edu.harvard.hul.ois.mets.helper.MetsWriter; import edu.harvard.hul.ois.mets.helper.PreformedXML; import java.io.File; import java.io.FileOutputStream; import java.io.UnsupportedEncodingException; import java.net.URLEncoder; import org.apache.log4j.Logger; import org.dspace.app.util.Util; import org.dspace.authorize.AuthorizeException; import org.dspace.authorize.AuthorizeManager; import org.dspace.content.Bitstream; import org.dspace.content.Bundle; import org.dspace.content.Community; import org.dspace.content.Collection; import org.dspace.content.DSpaceObject; import org.dspace.content.Item; import org.dspace.content.ItemIterator; import org.dspace.content.crosswalk.AbstractPackagerWrappingCrosswalk; import org.dspace.content.crosswalk.CrosswalkException; import org.dspace.content.crosswalk.CrosswalkObjectNotSupported; import org.dspace.content.crosswalk.DisseminationCrosswalk; import org.dspace.content.crosswalk.MODSDisseminationCrosswalk; import org.dspace.content.crosswalk.StreamDisseminationCrosswalk; import org.dspace.core.ConfigurationManager; import org.dspace.core.Constants; import org.dspace.core.Context; import org.dspace.core.PluginManager; import org.dspace.core.Utils; import org.dspace.license.CreativeCommons; import org.jdom.Element; import org.jdom.Namespace; import org.jdom.output.Format; import org.jdom.output.XMLOutputter; /** * Base class for disseminator of * METS (Metadata Encoding & Transmission Standard) Package.<br> * See <a href="http://www.loc.gov/standards/mets/">http://www.loc.gov/standards/mets/</a> * <p> * This is a generic packager framework intended to be subclassed to create * packagers for more specific METS "profiles". METS is an * abstract and flexible framework that can encompass many * different kinds of metadata and inner package structures. * <p> * <b>Package Parameters:</b><br> * <ul> * <li><code>manifestOnly</code> -- if true, generate a standalone XML * document of the METS manifest instead of a complete package. Any * other metadata (such as licenses) will be encoded inline. * Default is <code>false</code>.</li> * * <li><code>unauthorized</code> -- this determines what is done when the * packager encounters a Bundle or Bitstream it is not authorized to * read. By default, it just quits with an AuthorizeException. * If this option is present, it must be one of the following values: * <ul> * <li><code>skip</code> -- simply exclude unreadable content from package.</li> * <li><code>zero</code> -- include unreadable bitstreams as 0-length files; * unreadable Bundles will still cause authorize errors.</li></ul></li> * </ul> * * based on class by Larry Stone, Robert Tansley and Tim Donohue * @version $Revision$ */ public abstract class AbstractMETSDisseminator extends AbstractPackageDisseminator { /** log4j category */ private static Logger log = cz.cuni.mff.ufal.Logger.getLogger(AbstractMETSDisseminator.class); // JDOM xml output writer - indented format for readability. private static XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat()); // for gensym() private int idCounter = 1; /** * Default date/time (in milliseconds since epoch) to set for Zip Entries * for DSpace Objects which don't have a Last Modified date. If we don't * set our own date/time, then it will default to current system date/time. * This is less than ideal, as it causes the md5 checksum of Zip file to * change whenever Zip is regenerated (even if compressed files are unchanged) * 1036368000 seconds * 1000 = Nov 4, 2002 GMT (the date DSpace 1.0 was released) */ private static final int DEFAULT_MODIFIED_DATE = 1036368000 * 1000; /** * Suffix for Template objects (e.g. Item Templates) */ protected static final String TEMPLATE_TYPE_SUFFIX = " Template"; /** * Wrapper for a table of streams to add to the package, such as * mdRef'd metadata. Key is relative pathname of file, value is * <code>InputStream</code> with contents to put in it. Some * superclasses will put streams in this table when adding an mdRef * element to e.g. a rightsMD segment. */ protected static class MdStreamCache { private Map<MdRef, InputStream> extraFiles = new HashMap<MdRef, InputStream>(); public void addStream(MdRef key, InputStream md) { extraFiles.put(key, md); } public Map<MdRef, InputStream> getMap() { return extraFiles; } public void close() throws IOException { for (InputStream is : extraFiles.values()) { is.close(); } } } /** * Make a new unique ID symbol with specified prefix. * @param prefix the prefix of the identifier, constrained to XML ID schema * @return a new string identifier unique in this session (instance). */ protected synchronized String gensym(String prefix) { return prefix + "_" + String.valueOf(idCounter++); } /** * Resets the unique ID counter used by gensym() method to * determine the @ID values of METS tags. */ protected synchronized void resetCounter() { idCounter = 1; } @Override public String getMIMEType(PackageParameters params) { return (params != null && (params.getBooleanProperty("manifestOnly", false))) ? "text/xml" : "application/zip"; } public void writeManifest(Context context, DSpaceObject dso, PackageParameters params, OutputStream outStream) throws PackageValidationException, CrosswalkException, AuthorizeException, SQLException, IOException, MetsException { Mets manifest = makeManifest(context, dso, params, null); // only validate METS if specified (default = true) if (params.getBooleanProperty("validate", true)) { manifest.validate(new MetsValidator()); } manifest.write(new MetsWriter(outStream)); } /** * Export the object (Item, Collection, or Community) as a * "package" on the indicated OutputStream. Package is any serialized * representation of the item, at the discretion of the implementing * class. It does not have to include content bitstreams. * <p> * Use the <code>params</code> parameter list to adjust the way the * package is made, e.g. including a "<code>metadataOnly</code>" * parameter might make the package a bare manifest in XML * instead of a Zip file including manifest and contents. * <p> * Throws an exception of the chosen object is not acceptable or there is * a failure creating the package. * * @param context DSpace context. * @param object DSpace object (item, collection, etc) * @param params Properties-style list of options specific to this packager * @param pkgFile File where export package should be written * @throws PackageValidationException if package cannot be created or there is * a fatal error in creating it. */ @Override public void disseminate(Context context, DSpaceObject dso, PackageParameters params, File pkgFile) throws PackageValidationException, CrosswalkException, AuthorizeException, SQLException, IOException { // Reset our 'unique' ID counter back to 1 (in case a previous dissemination was run) // This ensures that the @ID attributes of METS tags always begin at '1', which // also ensures that the Checksums don't change because of accidental @ID value changes. resetCounter(); FileOutputStream outStream = null; try { //Make sure our package file exists if (!pkgFile.exists()) { PackageUtils.createFile(pkgFile); } //Open up an output stream to write to package file outStream = new FileOutputStream(pkgFile); // Generate a true manifest-only "package", no external files/data & no need to zip up if (params != null && params.getBooleanProperty("manifestOnly", false)) { writeManifest(context, dso, params, outStream); } else { // make a Zip-based package writeZipPackage(context, dso, params, outStream); } //end if/else } //end try catch (MetsException e) { String errorMsg = "Error exporting METS for DSpace Object, type=" + Constants.typeText[dso.getType()] + ", handle=" + dso.getHandle() + ", dbID=" + String.valueOf(dso.getID()); // We don't pass up a MetsException, so callers don't need to // know the details of the METS toolkit log.error(errorMsg, e); throw new PackageValidationException(errorMsg, e); } finally { //Close stream / stop writing to file if (outStream != null) { outStream.close(); } } } /** * Make a Zipped up METS package for the given DSpace Object * * @param context DSpace Context * @param dso The DSpace Object * @param params Parameters to the Packager script * @param pkg Package output stream * @throws PackageValidationException * @throws AuthorizeException * @throws SQLException * @throws IOException */ protected void writeZipPackage(Context context, DSpaceObject dso, PackageParameters params, OutputStream pkg) throws PackageValidationException, CrosswalkException, MetsException, AuthorizeException, SQLException, IOException { long lmTime = 0; if (dso.getType() == Constants.ITEM) { lmTime = ((Item) dso).getLastModified().getTime(); } // map of extra streams to put in Zip (these are located during makeManifest()) MdStreamCache extraStreams = new MdStreamCache(); ZipArchiveOutputStream zip = new ZipArchiveOutputStream(pkg); zip.setComment("METS archive created by DSpace " + Util.getSourceVersion()); Mets manifest = makeManifest(context, dso, params, extraStreams); // copy extra (metadata, license, etc) bitstreams into zip, update manifest if (extraStreams != null) { for (Map.Entry<MdRef, InputStream> ment : extraStreams.getMap().entrySet()) { MdRef ref = ment.getKey(); // Both Deposit Licenses & CC Licenses which are referenced as "extra streams" may already be // included in our Package (if their bundles are already included in the <filSec> section of manifest). // So, do a special check to see if we need to link up extra License <mdRef> entries to the bitstream in the <fileSec>. // (this ensures that we don't accidentally add the same License file to our package twice) linkLicenseRefsToBitstreams(context, params, dso, ref); //If this 'mdRef' is NOT already linked up to a file in the package, // then its file must be missing. So, we are going to add a new // file to the Zip package. if (ref.getXlinkHref() == null || ref.getXlinkHref().isEmpty()) { InputStream is = ment.getValue(); // create a hopefully unique filename within the Zip String fname = gensym("metadata"); // link up this 'mdRef' to point to that file ref.setXlinkHref(fname); if (log.isDebugEnabled()) { log.debug("Writing EXTRA stream to Zip: " + fname); } //actually add the file to the Zip package ZipArchiveEntry ze = new ZipArchiveEntry(fname); if (lmTime != 0) { ze.setTime(lmTime); } else //Set a default modified date so that checksum of Zip doesn't change if Zip contents are unchanged { ze.setTime(DEFAULT_MODIFIED_DATE); } zip.putArchiveEntry(ze); Utils.copy(is, zip); zip.closeArchiveEntry(); is.close(); } } } // write manifest after metadata. ZipArchiveEntry me = new ZipArchiveEntry(METSManifest.MANIFEST_FILE); if (lmTime != 0) { me.setTime(lmTime); } else //Set a default modified date so that checksum of Zip doesn't change if Zip contents are unchanged { me.setTime(DEFAULT_MODIFIED_DATE); } zip.putArchiveEntry(me); // can only validate now after fixing up extraStreams // note: only validate METS if specified (default = true) if (params.getBooleanProperty("validate", true)) { manifest.validate(new MetsValidator()); } manifest.write(new MetsWriter(zip)); zip.closeArchiveEntry(); //write any bitstreams associated with DSpace object to zip package addBitstreamsToZip(context, dso, params, zip); zip.close(); } /** * Add Bitstreams associated with a given DSpace Object into an * existing ZipArchiveOutputStream * @param context DSpace Context * @param dso The DSpace Object * @param params Parameters to the Packager script * @param zip Zip output */ protected void addBitstreamsToZip(Context context, DSpaceObject dso, PackageParameters params, ZipArchiveOutputStream zip) throws PackageValidationException, AuthorizeException, SQLException, IOException { // how to handle unauthorized bundle/bitstream: String unauth = (params == null) ? null : params.getProperty("unauthorized"); // copy all non-meta bitstreams into zip if (dso.getType() == Constants.ITEM) { Item item = (Item) dso; //get last modified time long lmTime = ((Item) dso).getLastModified().getTime(); Bundle bundles[] = item.getBundles(); for (int i = 0; i < bundles.length; i++) { if (includeBundle(bundles[i])) { // unauthorized bundle? if (!AuthorizeManager.authorizeActionBoolean(context, bundles[i], Constants.READ)) { if (unauth != null && (unauth.equalsIgnoreCase("skip"))) { log.warn("Skipping Bundle[\"" + bundles[i].getName() + "\"] because you are not authorized to read it."); continue; } else { throw new AuthorizeException( "Not authorized to read Bundle named \"" + bundles[i].getName() + "\""); } } Bitstream[] bitstreams = bundles[i].getBitstreams(); for (int k = 0; k < bitstreams.length; k++) { boolean auth = AuthorizeManager.authorizeActionBoolean(context, bitstreams[k], Constants.READ); if (auth || (unauth != null && unauth.equalsIgnoreCase("zero"))) { String zname = makeBitstreamURL(bitstreams[k], params); ZipArchiveEntry ze = new ZipArchiveEntry(zname); if (log.isDebugEnabled()) { log.debug(new StringBuilder().append("Writing CONTENT stream of bitstream(") .append(bitstreams[k].getID()).append(") to Zip: ").append(zname) .append(", size=").append(bitstreams[k].getSize()).toString()); } if (lmTime != 0) { ze.setTime(lmTime); } else //Set a default modified date so that checksum of Zip doesn't change if Zip contents are unchanged { ze.setTime(DEFAULT_MODIFIED_DATE); } ze.setSize(auth ? bitstreams[k].getSize() : 0); zip.putArchiveEntry(ze); if (auth) { InputStream input = bitstreams[k].retrieve(); Utils.copy(input, zip); input.close(); } else { log.warn("Adding zero-length file for Bitstream, SID=" + String.valueOf(bitstreams[k].getSequenceID()) + ", not authorized for READ."); } zip.closeArchiveEntry(); } else if (unauth != null && unauth.equalsIgnoreCase("skip")) { log.warn("Skipping Bitstream, SID=" + String.valueOf(bitstreams[k].getSequenceID()) + ", not authorized for READ."); } else { throw new AuthorizeException("Not authorized to read Bitstream, SID=" + String.valueOf(bitstreams[k].getSequenceID())); } } } } } // Coll, Comm just add logo bitstream to content if there is one else if (dso.getType() == Constants.COLLECTION || dso.getType() == Constants.COMMUNITY) { Bitstream logoBs = dso.getType() == Constants.COLLECTION ? ((Collection) dso).getLogo() : ((Community) dso).getLogo(); if (logoBs != null) { String zname = makeBitstreamURL(logoBs, params); ZipArchiveEntry ze = new ZipArchiveEntry(zname); if (log.isDebugEnabled()) { log.debug("Writing CONTENT stream of bitstream(" + String.valueOf(logoBs.getID()) + ") to Zip: " + zname + ", size=" + String.valueOf(logoBs.getSize())); } ze.setSize(logoBs.getSize()); //Set a default modified date so that checksum of Zip doesn't change if Zip contents are unchanged ze.setTime(DEFAULT_MODIFIED_DATE); zip.putArchiveEntry(ze); Utils.copy(logoBs.retrieve(), zip); zip.closeArchiveEntry(); } } } // set metadata type - if Mdtype.parse() gets exception, // that means it's not in the MDTYPE vocabulary, so use OTHER. protected void setMdType(MdWrap mdWrap, String mdtype) { try { mdWrap.setMDTYPE(Mdtype.parse(mdtype)); } catch (MetsException e) { mdWrap.setMDTYPE(Mdtype.OTHER); mdWrap.setOTHERMDTYPE(mdtype); } } // set metadata type - if Mdtype.parse() gets exception, // that means it's not in the MDTYPE vocabulary, so use OTHER. protected void setMdType(MdRef mdRef, String mdtype) { try { mdRef.setMDTYPE(Mdtype.parse(mdtype)); } catch (MetsException e) { mdRef.setMDTYPE(Mdtype.OTHER); mdRef.setOTHERMDTYPE(mdtype); } } /** * Create an element wrapped around a metadata reference (either mdWrap * or mdRef); i.e. dmdSec, techMd, sourceMd, etc. Checks for * XML-DOM oriented crosswalk first, then if not found looks for * stream crosswalk of the same name. * * @param context DSpace Context * @param dso DSpace Object we are generating METS manifest for * @param mdSecClass class of mdSec (TechMD, RightsMD, DigiProvMD, etc) * @param typeSpec Type of metadata going into this mdSec (e.g. MODS, DC, PREMIS, etc) * @param params the PackageParameters * @param extraStreams list of extra files which need to be added to final dissemination package * * @return mdSec element or null if xwalk returns empty results. * * @throws SQLException * @throws PackageValidationException * @throws CrosswalkException * @throws IOException * @throws AuthorizeException */ protected MdSec makeMdSec(Context context, DSpaceObject dso, Class mdSecClass, String typeSpec, PackageParameters params, MdStreamCache extraStreams) throws SQLException, PackageValidationException, CrosswalkException, IOException, AuthorizeException { try { //create our metadata element (dmdSec, techMd, sourceMd, rightsMD etc.) MdSec mdSec = (MdSec) mdSecClass.newInstance(); mdSec.setID(gensym(mdSec.getLocalName())); String parts[] = typeSpec.split(":", 2); String xwalkName, metsName; //determine the name of the crosswalk to use to generate metadata // for dmdSecs this is the part *after* the colon in the 'type' (see getDmdTypes()) // for all other mdSecs this is usually just corresponds to type name. if (parts.length > 1) { metsName = parts[0]; xwalkName = parts[1]; } else { metsName = typeSpec; xwalkName = typeSpec; } // First, check to see if the crosswalk we are using is a normal DisseminationCrosswalk boolean xwalkFound = PluginManager.hasNamedPlugin(DisseminationCrosswalk.class, xwalkName); if (xwalkFound) { // Find the crosswalk we will be using to generate the metadata for this mdSec DisseminationCrosswalk xwalk = (DisseminationCrosswalk) PluginManager .getNamedPlugin(DisseminationCrosswalk.class, xwalkName); if (xwalk.canDisseminate(dso)) { // Check if our Crosswalk actually wraps another Packager Plugin if (xwalk instanceof AbstractPackagerWrappingCrosswalk) { // If this crosswalk wraps another Packager Plugin, we can pass it our Packaging Parameters // (which essentially allow us to customize the output of the crosswalk) AbstractPackagerWrappingCrosswalk wrapper = (AbstractPackagerWrappingCrosswalk) xwalk; wrapper.setPackagingParameters(params); } //For a normal DisseminationCrosswalk, we will be expecting an XML (DOM) based result. // So, we are going to wrap this XML result in an <mdWrap> element MdWrap mdWrap = new MdWrap(); setMdType(mdWrap, metsName); XmlData xmlData = new XmlData(); if (crosswalkToMetsElement(xwalk, dso, xmlData) != null) { mdWrap.getContent().add(xmlData); mdSec.getContent().add(mdWrap); return mdSec; } else { return null; } } else { return null; } } // If we didn't find the correct crosswalk, we will check to see if this is // a StreamDisseminationCrosswalk -- a Stream crosswalk disseminates to an OutputStream else { StreamDisseminationCrosswalk sxwalk = (StreamDisseminationCrosswalk) PluginManager .getNamedPlugin(StreamDisseminationCrosswalk.class, xwalkName); if (sxwalk != null) { if (sxwalk.canDisseminate(context, dso)) { // Check if our Crosswalk actually wraps another Packager Plugin if (sxwalk instanceof AbstractPackagerWrappingCrosswalk) { // If this crosswalk wraps another Packager Plugin, we can pass it our Packaging Parameters // (which essentially allow us to customize the output of the crosswalk) AbstractPackagerWrappingCrosswalk wrapper = (AbstractPackagerWrappingCrosswalk) sxwalk; wrapper.setPackagingParameters(params); } // Disseminate crosswalk output to an outputstream ByteArrayOutputStream disseminateOutput = new ByteArrayOutputStream(); sxwalk.disseminate(context, dso, disseminateOutput); // Convert output to an inputstream, so we can write to manifest or Zip file ByteArrayInputStream crosswalkedStream = new ByteArrayInputStream( disseminateOutput.toByteArray()); //If we are capturing extra files to put into a Zip package if (extraStreams != null) { //Create an <mdRef> -- we'll just reference the file by name in Zip package MdRef mdRef = new MdRef(); //add the crosswalked Stream to list of files to add to Zip package later extraStreams.addStream(mdRef, crosswalkedStream); //set properties on <mdRef> // Note, filename will get set on this <mdRef> later, // when we process all the 'extraStreams' mdRef.setMIMETYPE(sxwalk.getMIMEType()); setMdType(mdRef, metsName); mdRef.setLOCTYPE(Loctype.URL); mdSec.getContent().add(mdRef); } else { //If we are *not* capturing extra streams to add to Zip package later, // that means we are likely only generating a METS manifest // (i.e. manifestOnly = true) // In this case, the best we can do is take the crosswalked // Stream, base64 encode it, and add in an <mdWrap> field // First, create our <mdWrap> MdWrap mdWrap = new MdWrap(); mdWrap.setMIMETYPE(sxwalk.getMIMEType()); setMdType(mdWrap, metsName); // Now, create our <binData> and add base64 encoded contents to it. BinData binData = new BinData(); Base64 base64 = new Base64(crosswalkedStream); binData.getContent().add(base64); mdWrap.getContent().add(binData); mdSec.getContent().add(mdWrap); } return mdSec; } else { return null; } } else { throw new PackageValidationException("Cannot find " + xwalkName + " crosswalk plugin, either DisseminationCrosswalk or StreamDisseminationCrosswalk"); } } } catch (InstantiationException e) { throw new PackageValidationException("Error instantiating Mdsec object: " + e.toString(), e); } catch (IllegalAccessException e) { throw new PackageValidationException("Error instantiating Mdsec object: " + e.toString(), e); } } // add either a techMd or sourceMd element to amdSec. // mdSecClass determines which type. // mdTypes[] is array of "[metsName:]PluginName" strings, maybe empty. protected void addToAmdSec(AmdSec fAmdSec, String mdTypes[], Class mdSecClass, Context context, DSpaceObject dso, PackageParameters params, MdStreamCache extraStreams) throws SQLException, PackageValidationException, CrosswalkException, IOException, AuthorizeException { for (int i = 0; i < mdTypes.length; ++i) { MdSec md = makeMdSec(context, dso, mdSecClass, mdTypes[i], params, extraStreams); if (md != null) { fAmdSec.getContent().add(md); } } } // Create amdSec for any tech md's, return its ID attribute. protected String addAmdSec(Context context, DSpaceObject dso, PackageParameters params, Mets mets, MdStreamCache extraStreams) throws SQLException, PackageValidationException, CrosswalkException, IOException, AuthorizeException { String techMdTypes[] = getTechMdTypes(context, dso, params); String rightsMdTypes[] = getRightsMdTypes(context, dso, params); String sourceMdTypes[] = getSourceMdTypes(context, dso, params); String digiprovMdTypes[] = getDigiprovMdTypes(context, dso, params); // only bother if there are any sections to add if ((techMdTypes.length + sourceMdTypes.length + digiprovMdTypes.length + rightsMdTypes.length) > 0) { String result = gensym("amd"); AmdSec fAmdSec = new AmdSec(); fAmdSec.setID(result); addToAmdSec(fAmdSec, techMdTypes, TechMD.class, context, dso, params, extraStreams); addToAmdSec(fAmdSec, rightsMdTypes, RightsMD.class, context, dso, params, extraStreams); addToAmdSec(fAmdSec, sourceMdTypes, SourceMD.class, context, dso, params, extraStreams); addToAmdSec(fAmdSec, digiprovMdTypes, DigiprovMD.class, context, dso, params, extraStreams); mets.getContent().add(fAmdSec); return result; } else { return null; } } // make the most "persistent" identifier possible, preferably a URN // based on the Handle. protected String makePersistentID(DSpaceObject dso) { String handle = dso.getHandle(); // If no Handle, punt to much-less-satisfactory database ID and type.. if (handle == null) { return "DSpace_DB_" + Constants.typeText[dso.getType()] + "_" + String.valueOf(dso.getID()); } else { return getHandleURN(handle); } } /** * Write out a METS manifest. * Mostly lifted from Rob Tansley's METS exporter. */ protected Mets makeManifest(Context context, DSpaceObject dso, PackageParameters params, MdStreamCache extraStreams) throws MetsException, PackageValidationException, CrosswalkException, AuthorizeException, SQLException, IOException { // Create the METS manifest in memory Mets mets = new Mets(); String identifier = "DB-ID-" + dso.getID(); if (dso.getHandle() != null) { identifier = dso.getHandle().replace('/', '-'); } // this ID should be globally unique (format: DSpace_[objType]_[handle with slash replaced with a dash]) mets.setID("DSpace_" + Constants.typeText[dso.getType()] + "_" + identifier); // identifies the object described by this document mets.setOBJID(makePersistentID(dso)); mets.setTYPE(getObjectTypeString(dso)); // this is the signature by which the ingester will recognize // a document it can expect to interpret. mets.setPROFILE(getProfile()); MetsHdr metsHdr = makeMetsHdr(context, dso, params); if (metsHdr != null) { mets.getContent().add(metsHdr); } // add DMD sections // Each type element MAY be either just a MODS-and-crosswalk name, OR // a combination "MODS-name:crosswalk-name" (e.g. "DC:qDC"). String dmdTypes[] = getDmdTypes(context, dso, params); // record of ID of each dmdsec to make DMDID in structmap. String dmdId[] = new String[dmdTypes.length]; for (int i = 0; i < dmdTypes.length; ++i) { MdSec dmdSec = makeMdSec(context, dso, DmdSec.class, dmdTypes[i], params, extraStreams); if (dmdSec != null) { mets.getContent().add(dmdSec); dmdId[i] = dmdSec.getID(); } } // add object-wide technical/source MD segments, get ID string: // Put that ID in ADMID of first div in structmap. String objectAMDID = addAmdSec(context, dso, params, mets, extraStreams); // Create simple structMap: initial div represents the Object's // contents, its children are e.g. Item bitstreams (content only), // Collection's members, or Community's members. StructMap structMap = new StructMap(); structMap.setID(gensym("struct")); structMap.setTYPE("LOGICAL"); structMap.setLABEL("DSpace Object"); Div div0 = new Div(); div0.setID(gensym("div")); div0.setTYPE("DSpace Object Contents"); structMap.getContent().add(div0); // fileSec is optional, let object type create it if needed. FileSec fileSec = null; // Item-specific manifest - license, bitstreams as Files, etc. if (dso.getType() == Constants.ITEM) { // this tags file ID and group identifiers for bitstreams. String bitstreamIDstart = "bitstream_"; Item item = (Item) dso; // how to handle unauthorized bundle/bitstream: String unauth = (params == null) ? null : params.getProperty("unauthorized"); // fileSec - all non-metadata bundles go into fileGrp, // and each bitstream therein into a file. // Create the bitstream-level techMd and div's for structmap // at the same time so we can connect the IDREFs to IDs. fileSec = new FileSec(); Bundle[] bundles = item.getBundles(); for (int i = 0; i < bundles.length; i++) { if (!includeBundle(bundles[i])) { continue; } // unauthorized bundle? // NOTE: This must match the logic in disseminate() if (!AuthorizeManager.authorizeActionBoolean(context, bundles[i], Constants.READ)) { if (unauth != null && (unauth.equalsIgnoreCase("skip"))) { continue; } else { throw new AuthorizeException( "Not authorized to read Bundle named \"" + bundles[i].getName() + "\""); } } Bitstream[] bitstreams = bundles[i].getBitstreams(); // Create a fileGrp, USE = permuted Bundle name FileGrp fileGrp = new FileGrp(); String bName = bundles[i].getName(); if ((bName != null) && !bName.equals("")) { fileGrp.setUSE(bundleToFileGrp(bName)); } // add technical metadata for a bundle String techBundID = addAmdSec(context, bundles[i], params, mets, extraStreams); if (techBundID != null) { fileGrp.setADMID(techBundID); } // watch for primary bitstream int primaryBitstreamID = -1; boolean isContentBundle = false; if ((bName != null) && bName.equals("ORIGINAL")) { isContentBundle = true; primaryBitstreamID = bundles[i].getPrimaryBitstreamID(); } // For each bitstream, add to METS manifest for (int bits = 0; bits < bitstreams.length; bits++) { // Check for authorization. Handle unauthorized // bitstreams to match the logic in disseminate(), // i.e. "unauth=zero" means include a 0-length bitstream, // "unauth=skip" means to ignore it (and exclude from // manifest). boolean auth = AuthorizeManager.authorizeActionBoolean(context, bitstreams[bits], Constants.READ); if (!auth) { if (unauth != null && unauth.equalsIgnoreCase("skip")) { continue; } else if (!(unauth != null && unauth.equalsIgnoreCase("zero"))) { throw new AuthorizeException("Not authorized to read Bitstream, SID=" + String.valueOf(bitstreams[bits].getSequenceID())); } } String sid = String.valueOf(bitstreams[bits].getSequenceID()); String fileID = bitstreamIDstart + sid; edu.harvard.hul.ois.mets.File file = new edu.harvard.hul.ois.mets.File(); file.setID(fileID); file.setSEQ(bitstreams[bits].getSequenceID()); fileGrp.getContent().add(file); // set primary bitstream in structMap if (bitstreams[bits].getID() == primaryBitstreamID) { Fptr fptr = new Fptr(); fptr.setFILEID(fileID); div0.getContent().add(0, fptr); } // if this is content, add to structmap too: if (isContentBundle) { div0.getContent().add(makeFileDiv(fileID, getObjectTypeString(bitstreams[bits]))); } /* * If we're in THUMBNAIL or TEXT bundles, the bitstream is * extracted text or a thumbnail, so we use the name to work * out which bitstream to be in the same group as */ String groupID = "GROUP_" + bitstreamIDstart + sid; if ((bundles[i].getName() != null) && (bundles[i].getName().equals("THUMBNAIL") || bundles[i].getName().startsWith("TEXT"))) { // Try and find the original bitstream, and chuck the // derived bitstream in the same group Bitstream original = findOriginalBitstream(item, bitstreams[bits]); if (original != null) { groupID = "GROUP_" + bitstreamIDstart + original.getSequenceID(); } } file.setGROUPID(groupID); file.setMIMETYPE(bitstreams[bits].getFormat().getMIMEType()); file.setSIZE(auth ? bitstreams[bits].getSize() : 0); // Translate checksum and type to METS String csType = bitstreams[bits].getChecksumAlgorithm(); String cs = bitstreams[bits].getChecksum(); if (auth && cs != null && csType != null) { try { file.setCHECKSUMTYPE(Checksumtype.parse(csType)); file.setCHECKSUM(cs); } catch (MetsException e) { log.warn("Cannot set bitstream checksum type=" + csType + " in METS."); } } // FLocat: point to location of bitstream contents. FLocat flocat = new FLocat(); flocat.setLOCTYPE(Loctype.URL); flocat.setXlinkHref(makeBitstreamURL(bitstreams[bits], params)); file.getContent().add(flocat); // technical metadata for bitstream String techID = addAmdSec(context, bitstreams[bits], params, mets, extraStreams); if (techID != null) { file.setADMID(techID); } } fileSec.getContent().add(fileGrp); } } else if (dso.getType() == Constants.COLLECTION) { Collection collection = (Collection) dso; ItemIterator ii = collection.getItems(); while (ii.hasNext()) { //add a child <div> for each item in collection Item item = ii.next(); Div childDiv = makeChildDiv(getObjectTypeString(item), item, params); if (childDiv != null) { div0.getContent().add(childDiv); } } // add metadata & info for Template Item, if exists Item templateItem = collection.getTemplateItem(); if (templateItem != null) { String templateDmdId[] = new String[dmdTypes.length]; // index where we should add the first template item <dmdSec>. // Index = number of <dmdSecs> already added + number of <metsHdr> = # of dmdSecs + 1 // (Note: in order to be a valid METS file, all dmdSecs must be before the 1st amdSec) int dmdIndex = dmdTypes.length + 1; //For each type of dmdSec specified, // add a new dmdSec which contains the Template Item metadata // (Note: Template Items are only metadata -- they have no content files) for (int i = 0; i < dmdTypes.length; ++i) { MdSec templateDmdSec = makeMdSec(context, templateItem, DmdSec.class, dmdTypes[i], params, extraStreams); if (templateDmdSec != null) { mets.getContent().add(dmdIndex, templateDmdSec); dmdIndex++; templateDmdId[i] = templateDmdSec.getID(); } } //Now add a child <div> in structMap to represent that Template Item Div templateItemDiv = new Div(); templateItemDiv.setID(gensym("div")); templateItemDiv.setTYPE(getObjectTypeString(templateItem) + TEMPLATE_TYPE_SUFFIX); //Link up the dmdSec(s) for the Template Item to this <div> StringBuilder templateDmdIds = new StringBuilder(); for (String currdmdId : templateDmdId) { templateDmdIds.append(" ").append(currdmdId); } templateItemDiv.setDMDID(templateDmdIds.substring(1)); //add this child <div> before the listing of normal Items div0.getContent().add(0, templateItemDiv); } // add link to Collection Logo, if one exists Bitstream logoBs = collection.getLogo(); if (logoBs != null) { fileSec = new FileSec(); addLogoBitstream(logoBs, fileSec, div0, params); } } else if (dso.getType() == Constants.COMMUNITY) { // Subcommunities are directly under "DSpace Object Contents" <div>, // but are labeled as Communities. Community subcomms[] = ((Community) dso).getSubcommunities(); for (int i = 0; i < subcomms.length; ++i) { //add a child <div> for each subcommunity in this community Div childDiv = makeChildDiv(getObjectTypeString(subcomms[i]), subcomms[i], params); if (childDiv != null) { div0.getContent().add(childDiv); } } // Collections are also directly under "DSpace Object Contents" <div>, // but are labeled as Collections. Collection colls[] = ((Community) dso).getCollections(); for (int i = 0; i < colls.length; ++i) { //add a child <div> for each collection in this community Div childDiv = makeChildDiv(getObjectTypeString(colls[i]), colls[i], params); if (childDiv != null) { div0.getContent().add(childDiv); } } //add Community logo bitstream Bitstream logoBs = ((Community) dso).getLogo(); if (logoBs != null) { fileSec = new FileSec(); addLogoBitstream(logoBs, fileSec, div0, params); } } else if (dso.getType() == Constants.SITE) { // This is a site-wide <structMap>, which just lists the top-level // communities. Each top level community is referenced by a div. Community comms[] = Community.findAllTop(context); for (int i = 0; i < comms.length; ++i) { //add a child <div> for each top level community in this site Div childDiv = makeChildDiv(getObjectTypeString(comms[i]), comms[i], params); if (childDiv != null) { div0.getContent().add(childDiv); } } } //Only add the <fileSec> to the METS file if it has content. A <fileSec> must have content. if (fileSec != null && fileSec.getContent() != null && !fileSec.getContent().isEmpty()) { mets.getContent().add(fileSec); } mets.getContent().add(structMap); // set links to metadata for object -- after type-specific // code since that can add to the object metadata. StringBuilder dmdIds = new StringBuilder(); for (String currdmdId : dmdId) { dmdIds.append(" ").append(currdmdId); } div0.setDMDID(dmdIds.substring(1)); if (objectAMDID != null) { div0.setADMID(objectAMDID); } // Does subclass have something to add to structMap? addStructMap(context, dso, params, mets); return mets; } // Install logo bitstream into METS for Community, Collection. // Add a file element, and refer to it from an fptr in the first div // of the main structMap. protected void addLogoBitstream(Bitstream logoBs, FileSec fileSec, Div div0, PackageParameters params) { edu.harvard.hul.ois.mets.File file = new edu.harvard.hul.ois.mets.File(); String fileID = gensym("logo"); file.setID(fileID); file.setMIMETYPE(logoBs.getFormat().getMIMEType()); file.setSIZE(logoBs.getSize()); // Translate checksum and type to METS String csType = logoBs.getChecksumAlgorithm(); String cs = logoBs.getChecksum(); if (cs != null && csType != null) { try { file.setCHECKSUMTYPE(Checksumtype.parse(csType)); file.setCHECKSUM(cs); } catch (MetsException e) { log.warn("Cannot set bitstream checksum type=" + csType + " in METS."); } } //Create <fileGroup USE="LOGO"> with a <FLocat> pointing at bitstream FLocat flocat = new FLocat(); flocat.setLOCTYPE(Loctype.URL); flocat.setXlinkHref(makeBitstreamURL(logoBs, params)); file.getContent().add(flocat); FileGrp fileGrp = new FileGrp(); fileGrp.setUSE("LOGO"); fileGrp.getContent().add(file); fileSec.getContent().add(fileGrp); // add fptr directly to div0 of structMap Fptr fptr = new Fptr(); fptr.setFILEID(fileID); div0.getContent().add(0, fptr); } // create <div> element pointing to a file protected Div makeFileDiv(String fileID, String type) { Div div = new Div(); div.setID(gensym("div")); div.setTYPE(type); Fptr fptr = new Fptr(); fptr.setFILEID(fileID); div.getContent().add(fptr); return div; } /** * Create a <div> element with <mptr> which references a child * object via its handle (and via a local file name, when recursively disseminating * all child objects). * @param type - type attr value for the <div> * @param dso - object for which to create the div * @param params * @return */ protected Div makeChildDiv(String type, DSpaceObject dso, PackageParameters params) { String handle = dso.getHandle(); //start <div> Div div = new Div(); div.setID(gensym("div")); div.setTYPE(type); //make sure we have a handle if (handle == null || handle.length() == 0) { log.warn("METS Disseminator is skipping " + type + " without handle: " + dso.toString()); } else { //create <mptr> with handle reference Mptr mptr = new Mptr(); mptr.setID(gensym("mptr")); mptr.setLOCTYPE(Loctype.HANDLE); mptr.setXlinkHref(handle); div.getContent().add(mptr); } //determine file extension of child references, //based on whether we are exporting just a manifest or a full Zip pkg String childFileExtension = (params.getBooleanProperty("manifestOnly", false)) ? "xml" : "zip"; // Always create <mptr> with file-name reference to child package // This is what DSpace will expect the child package to be named during ingestion // (NOTE: without this reference, DSpace will be unable to restore any child objects during ingestion) Mptr mptr2 = new Mptr(); mptr2.setID(gensym("mptr")); mptr2.setLOCTYPE(Loctype.URL); //we get the name of the child package from the Packager -- as it is what will actually create this child pkg file mptr2.setXlinkHref(PackageUtils.getPackageName(dso, childFileExtension)); div.getContent().add(mptr2); return div; } // put handle in canonical URN format -- note that HandleManager's // canonicalize currently returns HTTP URL format. protected String getHandleURN(String handle) { if (handle.startsWith("hdl:")) { return handle; } return "hdl:" + handle; } /** * For a bitstream that's a thumbnail or extracted text, find the * corresponding bitstream it was derived from, in the ORIGINAL bundle. * * @param item * the item we're dealing with * @param derived * the derived bitstream * * @return the corresponding original bitstream (or null) */ protected static Bitstream findOriginalBitstream(Item item, Bitstream derived) throws SQLException { Bundle[] bundles = item.getBundles(); // Filename of original will be filename of the derived bitstream // minus the extension (last 4 chars - .jpg or .txt) String originalFilename = derived.getName().substring(0, derived.getName().length() - 4); // First find "original" bundle for (int i = 0; i < bundles.length; i++) { if ((bundles[i].getName() != null) && bundles[i].getName().equals("ORIGINAL")) { // Now find the corresponding bitstream Bitstream[] bitstreams = bundles[i].getBitstreams(); for (int bsnum = 0; bsnum < bitstreams.length; bsnum++) { if (bitstreams[bsnum].getName().equals(originalFilename)) { return bitstreams[bsnum]; } } } } // Didn't find it return null; } // Get result from crosswalk plugin and add it to the document, // including namespaces and schema. // returns the new/modified element upon success. private MetsElement crosswalkToMetsElement(DisseminationCrosswalk xwalk, DSpaceObject dso, MetsElement me) throws CrosswalkException, IOException, SQLException, AuthorizeException { try { // add crosswalk's namespaces and schemaLocation to this element: String raw = xwalk.getSchemaLocation(); String sloc[] = raw == null ? null : raw.split("\\s+"); Namespace ns[] = xwalk.getNamespaces(); for (int i = 0; i < ns.length; ++i) { String uri = ns[i].getURI(); if (sloc != null && sloc.length > 1 && uri.equals(sloc[0])) { me.setSchema(ns[i].getPrefix(), uri, sloc[1]); } else { me.setSchema(ns[i].getPrefix(), uri); } } // add result of crosswalk PreformedXML pXML = null; if (xwalk.preferList()) { List<Element> res = xwalk.disseminateList(dso); if (!(res == null || res.isEmpty())) { pXML = new PreformedXML(outputter.outputString(res)); } } else { Element res = null; if (xwalk instanceof MODSDisseminationCrosswalk) { res = ((MODSDisseminationCrosswalk) xwalk).disseminateElement(dso, true); } else { res = xwalk.disseminateElement(dso); } if (res != null) { pXML = new PreformedXML(outputter.outputString(res)); } } if (pXML != null) { me.getContent().add(pXML); return me; } return null; } catch (CrosswalkObjectNotSupported e) { // ignore this xwalk if object is unsupported. if (log.isDebugEnabled()) { log.debug("Skipping MDsec because of CrosswalkObjectNotSupported: dso=" + dso.toString() + ", xwalk=" + xwalk.getClass().getName()); } return null; } } /** * Cleanup our license file reference links, as Deposit Licenses & CC Licenses can be * added two ways (and we only want to add them to zip package *once*): * (1) Added as a normal Bitstream (assuming LICENSE and CC_LICENSE bundles will be included in pkg) * (2) Added via a 'rightsMD' crosswalk (as they are rights information/metadata on an Item) * <p> * So, if they are being added by *both*, then we want to just link the rightsMD <mdRef> entry so * that it points to the Bitstream location. This implementation is a bit 'hackish', but it's * the best we can do, as the Harvard METS API doesn't allow us to go back and crawl an entire * METS file to look for these inconsistencies/duplications. * * @param context current DSpace Context * @param params current Packager Parameters * @param dso current DSpace Object * @param ref the rightsMD <mdRef> element * @throws SQLException * @throws IOException * @throws AuthorizeException */ protected void linkLicenseRefsToBitstreams(Context context, PackageParameters params, DSpaceObject dso, MdRef mdRef) throws SQLException, IOException, AuthorizeException { //If this <mdRef> is a reference to a DSpace Deposit License if (mdRef.getMDTYPE() != null && mdRef.getMDTYPE() == Mdtype.OTHER && mdRef.getOTHERMDTYPE() != null && mdRef.getOTHERMDTYPE().equals("DSpaceDepositLicense")) { //Locate the LICENSE bundle Item i = (Item) dso; Bundle license[] = i.getBundles(Constants.LICENSE_BUNDLE_NAME); //Are we already including the LICENSE bundle's bitstreams in this package? if (license != null && license.length > 0 && includeBundle(license[0])) { //Since we are including the LICENSE bitstreams, lets find our LICENSE bitstream path & link to it. Bitstream licenseBs = PackageUtils.findDepositLicense(context, (Item) dso); mdRef.setXlinkHref(makeBitstreamURL(licenseBs, params)); } } //If this <mdRef> is a reference to a Creative Commons Textual License else if (mdRef.getMDTYPE() != null && mdRef.getMDTYPE() == Mdtype.OTHER && mdRef.getOTHERMDTYPE() != null && mdRef.getOTHERMDTYPE().equals("CreativeCommonsText")) { //Locate the CC-LICENSE bundle Item i = (Item) dso; Bundle license[] = i.getBundles(CreativeCommons.CC_BUNDLE_NAME); //Are we already including the CC-LICENSE bundle's bitstreams in this package? if (license != null && license.length > 0 && includeBundle(license[0])) { //Since we are including the CC-LICENSE bitstreams, lets find our CC-LICENSE (textual) bitstream path & link to it. Bitstream ccText = CreativeCommons.getLicenseTextBitstream(i); mdRef.setXlinkHref(makeBitstreamURL(ccText, params)); } } //If this <mdRef> is a reference to a Creative Commons RDF License else if (mdRef.getMDTYPE() != null && mdRef.getMDTYPE() == Mdtype.OTHER && mdRef.getOTHERMDTYPE() != null && mdRef.getOTHERMDTYPE().equals("CreativeCommonsRDF")) { //Locate the CC-LICENSE bundle Item i = (Item) dso; Bundle license[] = i.getBundles(CreativeCommons.CC_BUNDLE_NAME); //Are we already including the CC-LICENSE bundle's bitstreams in this package? if (license != null && license.length > 0 && includeBundle(license[0])) { //Since we are including the CC-LICENSE bitstreams, lets find our CC-LICENSE (RDF) bitstream path & link to it. Bitstream ccRdf = CreativeCommons.getLicenseRdfBitstream(i); mdRef.setXlinkHref(makeBitstreamURL(ccRdf, params)); } } } /** * Build a string which will be used as the "Type" of this object in * the METS manifest. * <P> * Default format is "DSpace [Type-as-string]". * * @param dso DSpaceObject to create type-string for * @return a string which will represent this object Type in METS * @see org.dspace.core.Constants */ public String getObjectTypeString(DSpaceObject dso) { //Format: "DSpace <Type-as-string>" (e.g. "DSpace ITEM", "DSpace COLLECTION", etc) return "DSpace " + Constants.typeText[dso.getType()]; } /** * Returns a user help string which should describe the * additional valid command-line options that this packager * implementation will accept when using the <code>-o</code> or * <code>--option</code> flags with the Packager script. * * @return a string describing additional command-line options available * with this packager */ @Override public String getParameterHelp() { return "* manifestOnly=[boolean] " + "If true, only export the METS manifest (mets.xml) and don't export content files (defaults to false)." + "\n\n" + "* unauthorized=[value] " + "If 'skip', skip over any files which the user doesn't have authorization to read. " + "If 'zero', create a zero-length file for any files the user doesn't have authorization to read. " + "By default, an AuthorizationException will be thrown for any files the user cannot read."; } /** * Get the URL by which the METS manifest refers to a Bitstream * member within the same package. In other words, this is generally * a relative path link to where the Bitstream file is within the Zipped * up package. * <p> * For a manifest-only METS, this is a reference to an HTTP URL where * the bitstream should be able to be downloaded from. * * @param bitstream the Bitstream * @param params Packager Parameters * @return String in URL format naming path to bitstream. */ public String makeBitstreamURL(Bitstream bitstream, PackageParameters params) { // if bare manifest, use external "persistent" URI for bitstreams if (params != null && (params.getBooleanProperty("manifestOnly", false))) { // Try to build a persistent(-ish) URI for bitstream // Format: {site-base-url}/bitstream/{item-handle}/{sequence-id}/{bitstream-name} try { // get handle of parent Item of this bitstream, if there is one: String handle = null; Bundle[] bn = bitstream.getBundles(); if (bn.length > 0) { Item bi[] = bn[0].getItems(); if (bi.length > 0) { handle = bi[0].getHandle(); } } if (handle != null) { return ConfigurationManager.getProperty("dspace.url") + "/bitstream/" + handle + "/" + String.valueOf(bitstream.getSequenceID()) + "/" + URLEncoder.encode(bitstream.getName(), "UTF-8"); } else { //no Handle assigned, so persistent(-ish) URI for bitstream is // Format: {site-base-url}/retrieve/{bistream-internal-id} return ConfigurationManager.getProperty("dspace.url") + "/retrieve/" + String.valueOf(bitstream.getID()); } } catch (SQLException e) { log.error("Database problem", e); } catch (UnsupportedEncodingException e) { log.error("Unknown character set", e); } // We should only get here if we failed to build a nice URL above // so, by default, we're just going to return the bitstream name. return bitstream.getName(); } else { String base = "bitstream_" + String.valueOf(bitstream.getID()); String ext[] = bitstream.getFormat().getExtensions(); return (ext.length > 0) ? base + "." + ext[0] : base; } } /** * Create metsHdr element - separate so subclasses can override. */ public abstract MetsHdr makeMetsHdr(Context context, DSpaceObject dso, PackageParameters params); /** * Returns name of METS profile to which this package conforms, e.g. * "DSpace METS DIP Profile 1.0" * @return string name of profile. */ public abstract String getProfile(); /** * Returns fileGrp's USE attribute value corresponding to a DSpace bundle name. * * @param bname name of DSpace bundle. * @return string name of fileGrp */ public abstract String bundleToFileGrp(String bname); /** * Get the types of Item-wide DMD to include in package. * Each element of the returned array is a String, which * MAY be just a simple name, naming both the Crosswalk Plugin and * the METS "MDTYPE", <em>or</em> a colon-separated pair consisting of * the METS name followed by a colon and the Crosswalk Plugin name. * E.g. the type string <code>"DC:qualifiedDublinCore"</code> tells it to * create a METS section with <code>MDTYPE="DC"</code> and use the plugin * named "qualifiedDublinCore" to obtain the data. * @param params the PackageParameters passed to the disseminator. * @return array of metadata type strings, never null. */ public abstract String[] getDmdTypes(Context context, DSpaceObject dso, PackageParameters params) throws SQLException, IOException, AuthorizeException; /** * Get the type string of the technical metadata to create for each * object and each Bitstream in an Item. The type string may be a * simple name or colon-separated compound as specified for * <code>getDmdTypes()</code> above. * @param params the PackageParameters passed to the disseminator. * @return array of metadata type strings, never null. */ public abstract String[] getTechMdTypes(Context context, DSpaceObject dso, PackageParameters params) throws SQLException, IOException, AuthorizeException; /** * Get the type string of the source metadata to create for each * object and each Bitstream in an Item. The type string may be a * simple name or colon-separated compound as specified for * <code>getDmdTypes()</code> above. * @param params the PackageParameters passed to the disseminator. * @return array of metadata type strings, never null. */ public abstract String[] getSourceMdTypes(Context context, DSpaceObject dso, PackageParameters params) throws SQLException, IOException, AuthorizeException; /** * Get the type string of the "digiprov" (digital provenance) * metadata to create for each object and each Bitstream in an Item. * The type string may be a simple name or colon-separated compound * as specified for <code>getDmdTypes()</code> above. * * @param params the PackageParameters passed to the disseminator. * @return array of metadata type strings, never null. */ public abstract String[] getDigiprovMdTypes(Context context, DSpaceObject dso, PackageParameters params) throws SQLException, IOException, AuthorizeException; /** * Get the type string of the "rights" (permission and/or license) * metadata to create for each object and each Bitstream in an Item. * The type string may be a simple name or colon-separated compound * as specified for <code>getDmdTypes()</code> above. * * @param params the PackageParameters passed to the disseminator. * @return array of metadata type strings, never null. */ public abstract String[] getRightsMdTypes(Context context, DSpaceObject dso, PackageParameters params) throws SQLException, IOException, AuthorizeException; /** * Add any additional <code>structMap</code> elements to the * METS document, as required by this subclass. A simple default * structure map which fulfills the minimal DSpace METS DIP/SIP * requirements is already present, so this does not need to do anything. * @param mets the METS document to which to add structMaps */ public abstract void addStructMap(Context context, DSpaceObject dso, PackageParameters params, Mets mets) throws SQLException, IOException, AuthorizeException, MetsException; /** * @return true when this bundle should be included as "content" * in the package.. e.g. DSpace SIP does not include metadata bundles. */ public abstract boolean includeBundle(Bundle bundle); }