/**
* each entry represents a bitstream....
*
* @param c
* @param i
* @param path
* @param fileName
* @param bundleName
* @throws SQLException
* @throws IOException
* @throws AuthorizeException
*/
private void processContentFileEntry(
Context c, Item i, String path, String fileName, String bundleName, boolean primary)
throws SQLException, IOException, AuthorizeException {
String fullpath = path + File.separatorChar + fileName;
// get an input stream
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(fullpath));
Bitstream bs = null;
String newBundleName = bundleName;
if (bundleName == null) {
// is it license.txt?
if ("license.txt".equals(fileName)) {
newBundleName = "LICENSE";
} else {
// call it ORIGINAL
newBundleName = "ORIGINAL";
}
}
if (!isTest) {
// find the bundle
Bundle[] bundles = i.getBundles(newBundleName);
Bundle targetBundle = null;
if (bundles.length < 1) {
// not found, create a new one
targetBundle = i.createBundle(newBundleName);
} else {
// put bitstreams into first bundle
targetBundle = bundles[0];
}
// now add the bitstream
bs = targetBundle.createBitstream(bis);
bs.setName(fileName);
// Identify the format
// FIXME - guessing format guesses license.txt incorrectly as a text
// file format!
BitstreamFormat bf = FormatIdentifier.guessFormat(c, bs);
bs.setFormat(bf);
// Is this a the primary bitstream?
if (primary) {
targetBundle.setPrimaryBitstreamID(bs.getID());
targetBundle.update();
}
bs.update();
}
bis.close();
}
/**
* Register the bitstream file into DSpace
*
* @param c
* @param i
* @param assetstore
* @param bitstreamPath the full filepath expressed in the contents file
* @param bundleName
* @throws SQLException
* @throws IOException
* @throws AuthorizeException
*/
private void registerBitstream(
Context c, Item i, int assetstore, String bitstreamPath, String bundleName)
throws SQLException, IOException, AuthorizeException {
// TODO validate assetstore number
// TODO make sure the bitstream is there
Bitstream bs = null;
String newBundleName = bundleName;
if (bundleName == null) {
// is it license.txt?
if (bitstreamPath.endsWith("license.txt")) {
newBundleName = "LICENSE";
} else {
// call it ORIGINAL
newBundleName = "ORIGINAL";
}
}
if (!isTest) {
// find the bundle
Bundle[] bundles = i.getBundles(newBundleName);
Bundle targetBundle = null;
if (bundles.length < 1) {
// not found, create a new one
targetBundle = i.createBundle(newBundleName);
} else {
// put bitstreams into first bundle
targetBundle = bundles[0];
}
// now add the bitstream
bs = targetBundle.registerBitstream(assetstore, bitstreamPath);
// set the name to just the filename
int iLastSlash = bitstreamPath.lastIndexOf('/');
bs.setName(bitstreamPath.substring(iLastSlash + 1));
// Identify the format
// FIXME - guessing format guesses license.txt incorrectly as a text file format!
BitstreamFormat bf = FormatIdentifier.guessFormat(c, bs);
bs.setFormat(bf);
bs.update();
}
}
/**
* Process Item, correcting CC-License if encountered.
*
* @param item
* @throws SQLException
* @throws AuthorizeException
* @throws IOException
*/
protected static void handleItem(Item item) throws SQLException, AuthorizeException, IOException {
Bundle[] bundles = item.getBundles("CC-LICENSE");
if (bundles == null || bundles.length == 0) return;
Bundle bundle = bundles[0];
Bitstream bitstream = bundle.getBitstreamByName("license_rdf");
String license_rdf = new String(copy(bitstream));
/* quickly fix xml by ripping out offensive parts */
license_rdf = license_rdf.replaceFirst("<license", "");
license_rdf = license_rdf.replaceFirst("</license>", "");
StringWriter result = new StringWriter();
try {
templates
.newTransformer()
.transform(
new StreamSource(new ByteArrayInputStream(license_rdf.getBytes())),
new StreamResult(result));
} catch (TransformerException e) {
throw new RuntimeException(e.getMessage(), e);
}
StringBuffer buffer = result.getBuffer();
Bitstream newBitstream =
bundle.createBitstream(new ByteArrayInputStream(buffer.toString().getBytes()));
newBitstream.setName(bitstream.getName());
newBitstream.setDescription(bitstream.getDescription());
newBitstream.setFormat(bitstream.getFormat());
newBitstream.setSource(bitstream.getSource());
newBitstream.setUserFormatDescription(bitstream.getUserFormatDescription());
newBitstream.update();
bundle.removeBitstream(bitstream);
bundle.update();
}
/* (non-Javadoc)
* @see org.dspace.app.dav.DAVResource#proppatchInternal(int, org.jdom.Element)
*/
@Override
protected int proppatchInternal(int action, Element prop)
throws SQLException, AuthorizeException, IOException, DAVStatusException {
String newValue = (action == DAV.PROPPATCH_REMOVE) ? null : prop.getText();
// these are "metadata" values..
if (elementsEqualIsh(prop, short_descriptionProperty)
|| elementsEqualIsh(prop, introductory_textProperty)
|| elementsEqualIsh(prop, side_bar_textProperty)
|| elementsEqualIsh(prop, copyright_textProperty)
|| elementsEqualIsh(prop, provenance_descriptionProperty)) {
this.collection.setMetadata(prop.getName(), newValue);
} else if (elementsEqualIsh(prop, displaynameProperty)) {
this.collection.setMetadata("name", newValue);
} else if (elementsEqualIsh(prop, default_licenseProperty)) {
this.collection.setLicense(newValue);
} else if (elementsEqualIsh(prop, logoProperty)) {
if (action == DAV.PROPPATCH_REMOVE) {
this.collection.setLogo(null);
} else {
Element bs = prop.getChild("bitstream", DAV.NS_DSPACE);
if (bs != null) {
InputStream bis = DAVBitstream.getXmlBitstreamContent(this.context, bs);
BitstreamFormat bsf = DAVBitstream.getXmlBitstreamFormat(this.context, bs);
if (bis == null || bsf == null) {
throw new DAVStatusException(DAV.SC_CONFLICT, "Unacceptable value for logo property.");
}
Bitstream nbs = this.collection.setLogo(bis);
nbs.setFormat(bsf);
nbs.update();
} else {
throw new DAVStatusException(
DAV.SC_CONFLICT, "No <bitstream> element value found for logo property.");
}
}
} else {
throw new DAVStatusException(
DAV.SC_CONFLICT, "The " + prop.getName() + " property cannot be changed.");
}
this.collection.update();
return HttpServletResponse.SC_OK;
}
/**
* Perform a deposit, using the supplied SWORD Deposit object.
*
* @param deposit
* @throws SWORDErrorException
* @throws DSpaceSWORDException
*/
public DepositResult doDeposit(Deposit deposit) throws SWORDErrorException, DSpaceSWORDException {
// get the things out of the service that we need
Context context = swordService.getContext();
SWORDConfiguration swordConfig = swordService.getSwordConfig();
SWORDUrlManager urlManager = swordService.getUrlManager();
// FIXME: the spec is unclear what to do in this situation. I'm going
// the throw a 415 (ERROR_CONTENT) until further notice
//
// determine if this is an acceptable file format
if (!swordConfig.isAcceptableContentType(context, deposit.getContentType(), collection)) {
log.error(
"Unacceptable content type detected: "
+ deposit.getContentType()
+ " for collection "
+ collection.getID());
throw new SWORDErrorException(
ErrorCodes.ERROR_CONTENT,
"Unacceptable content type in deposit request: " + deposit.getContentType());
}
// determine if this is an acceptable packaging type for the deposit
// if not, we throw a 415 HTTP error (Unsupported Media Type, ERROR_CONTENT)
if (!swordConfig.isSupportedMediaType(deposit.getPackaging(), this.collection)) {
log.error(
"Unacceptable packaging type detected: "
+ deposit.getPackaging()
+ "for collection"
+ collection.getID());
throw new SWORDErrorException(
ErrorCodes.ERROR_CONTENT,
"Unacceptable packaging type in deposit request: " + deposit.getPackaging());
}
// Obtain the relevant ingester from the factory
SWORDIngester si = SWORDIngesterFactory.getInstance(context, deposit, collection);
swordService.message("Loaded ingester: " + si.getClass().getName());
// do the deposit
DepositResult result = si.ingest(swordService, deposit, collection);
swordService.message("Archive ingest completed successfully");
// if there's an item availalble, and we want to keep the original
// then do that
try {
if (swordConfig.isKeepOriginal()) {
swordService.message(
"DSpace will store an original copy of the deposit, "
+ "as well as ingesting the item into the archive");
// in order to be allowed to add the file back to the item, we need to ignore authorisations
// for a moment
boolean ignoreAuth = context.ignoreAuthorization();
context.setIgnoreAuthorization(true);
String bundleName = ConfigurationManager.getProperty("sword-server", "bundle.name");
if (bundleName == null || "".equals(bundleName)) {
bundleName = "SWORD";
}
Item item = result.getItem();
Bundle[] bundles = item.getBundles(bundleName);
Bundle swordBundle = null;
if (bundles.length > 0) {
swordBundle = bundles[0];
}
if (swordBundle == null) {
swordBundle = item.createBundle(bundleName);
}
String fn = swordService.getFilename(context, deposit, true);
Bitstream bitstream;
FileInputStream fis = null;
try {
fis = new FileInputStream(deposit.getFile());
bitstream = swordBundle.createBitstream(fis);
} finally {
if (fis != null) {
fis.close();
}
}
bitstream.setName(fn);
bitstream.setDescription("SWORD deposit package");
BitstreamFormat bf = BitstreamFormat.findByMIMEType(context, deposit.getContentType());
if (bf != null) {
bitstream.setFormat(bf);
}
bitstream.update();
swordBundle.update();
item.update();
swordService.message(
"Original package stored as " + fn + ", in item bundle " + swordBundle);
// now reset the context ignore authorisation
context.setIgnoreAuthorization(ignoreAuth);
// set the media link for the created item
result.setMediaLink(urlManager.getMediaLink(bitstream));
} else {
// set the vanilla media link, which doesn't resolve to anything
result.setMediaLink(urlManager.getBaseMediaLinkUrl());
}
} catch (SQLException e) {
log.error("caught exception: ", e);
throw new DSpaceSWORDException(e);
} catch (AuthorizeException e) {
log.error("caught exception: ", e);
throw new DSpaceSWORDException(e);
} catch (FileNotFoundException e) {
log.error("caught exception: ", e);
throw new DSpaceSWORDException(e);
} catch (IOException e) {
log.error("caught exception: ", e);
throw new DSpaceSWORDException(e);
}
return result;
}
/**
* perform the ingest using the given deposit object onto the specified target dspace object,
* using the sword service implementation
*
* @param service
* @param deposit
* @param target
* @return
* @throws DSpaceSWORDException
* @throws SWORDErrorException
*/
public DepositResult ingest(SWORDService service, Deposit deposit, DSpaceObject target)
throws DSpaceSWORDException, SWORDErrorException {
try {
if (!(target instanceof Item)) {
throw new DSpaceSWORDException(
"SimpleFileIngester can only be loaded for deposit onto DSpace Items");
}
Item item = (Item) target;
// now set the sword service
SWORDService swordService = service;
// get the things out of the service that we need
Context context = swordService.getContext();
SWORDUrlManager urlManager = swordService.getUrlManager();
Bundle[] bundles = item.getBundles("ORIGINAL");
Bundle original;
if (bundles.length > 0) {
original = bundles[0];
} else {
original = item.createBundle("ORIGINAL");
}
Bitstream bs;
FileInputStream fis = null;
try {
fis = new FileInputStream(deposit.getFile());
bs = original.createBitstream(fis);
} finally {
if (fis != null) {
fis.close();
}
}
String fn = swordService.getFilename(context, deposit, false);
bs.setName(fn);
swordService.message("File created in item with filename " + fn);
BitstreamFormat bf = BitstreamFormat.findByMIMEType(context, deposit.getContentType());
if (bf != null) {
bs.setFormat(bf);
}
// to do the updates, we need to ignore authorisation in the context
boolean ignoreAuth = context.ignoreAuthorization();
context.setIgnoreAuthorization(true);
bs.update();
original.update();
item.update();
// reset the ignore authorisation
context.setIgnoreAuthorization(ignoreAuth);
DepositResult result = new DepositResult();
result.setHandle(urlManager.getBitstreamUrl(bs));
result.setTreatment(this.getTreatment());
result.setBitstream(bs);
return result;
} catch (SQLException e) {
throw new DSpaceSWORDException(e);
} catch (AuthorizeException e) {
throw new DSpaceSWORDException(e);
} catch (IOException e) {
throw new DSpaceSWORDException(e);
}
}
public static void main(String[] argv) throws Exception {
Options options = new Options();
options.addOption("c", "collection", true, "destination collection(s) Handle (repeatable)");
options.addOption("e", "eperson", true, "email address of eperson doing importing");
options.addOption(
"w",
"install",
false,
"disable workflow; install immediately without going through collection's workflow");
options.addOption("t", "type", true, "package type or MIMEtype");
options.addOption(
"o", "option", true, "Packager option to pass to plugin, \"name=value\" (repeatable)");
options.addOption(
"d", "disseminate", false, "Disseminate package (output); default is to submit.");
options.addOption("i", "item", true, "Handle of item to disseminate.");
options.addOption("h", "help", false, "help");
CommandLineParser parser = new PosixParser();
CommandLine line = parser.parse(options, argv);
String sourceFile = null;
String eperson = null;
String[] collections = null;
boolean useWorkflow = true;
String packageType = null;
boolean submit = true;
String itemHandle = null;
PackageParameters pkgParams = new PackageParameters();
if (line.hasOption('h')) {
HelpFormatter myhelp = new HelpFormatter();
myhelp.printHelp("Packager [options] package-file|-\n", options);
System.out.println("\nAvailable Submission Package (SIP) types:");
String pn[] = PluginManager.getAllPluginNames(PackageIngester.class);
for (int i = 0; i < pn.length; ++i) System.out.println(" " + pn[i]);
System.out.println("\nAvailable Dissemination Package (DIP) types:");
pn = PluginManager.getAllPluginNames(PackageDisseminator.class);
for (int i = 0; i < pn.length; ++i) System.out.println(" " + pn[i]);
System.exit(0);
}
if (line.hasOption('w')) useWorkflow = false;
if (line.hasOption('e')) eperson = line.getOptionValue('e');
if (line.hasOption('c')) collections = line.getOptionValues('c');
if (line.hasOption('t')) packageType = line.getOptionValue('t');
if (line.hasOption('i')) itemHandle = line.getOptionValue('i');
String files[] = line.getArgs();
if (files.length > 0) sourceFile = files[0];
if (line.hasOption('d')) submit = false;
if (line.hasOption('o')) {
String popt[] = line.getOptionValues('o');
for (int i = 0; i < popt.length; ++i) {
String pair[] = popt[i].split("\\=", 2);
if (pair.length == 2) pkgParams.addProperty(pair[0].trim(), pair[1].trim());
else if (pair.length == 1) pkgParams.addProperty(pair[0].trim(), "");
else System.err.println("Warning: Illegal package option format: \"" + popt[i] + "\"");
}
}
// Sanity checks on arg list: required args
if (sourceFile == null
|| eperson == null
|| packageType == null
|| (submit && collections == null)) {
System.err.println("Error - missing a REQUIRED argument or option.\n");
HelpFormatter myhelp = new HelpFormatter();
myhelp.printHelp("PackageManager [options] package-file|-\n", options);
System.exit(0);
}
// find the EPerson, assign to context
Context context = new Context();
EPerson myEPerson = null;
myEPerson = EPerson.findByEmail(context, eperson);
if (myEPerson == null) usageError("Error, eperson cannot be found: " + eperson);
context.setCurrentUser(myEPerson);
if (submit) {
// make sure we have an input file
// GWaller 11/1/10 Disable piping of input in - we need to archive the package so it is
// simpler to assume a file stream
// rather than save the System.in bytes and re-read.
if (sourceFile.equals("-")) {
usageError(
"Error, input piping not allowed. Specify a file name of a physical file to read");
}
InputStream source = new FileInputStream(sourceFile);
PackageIngester sip =
(PackageIngester) PluginManager.getNamedPlugin(PackageIngester.class, packageType);
if (sip == null) usageError("Error, Unknown package type: " + packageType);
// find collections
Collection[] mycollections = null;
System.out.println("Destination collections:");
// validate each collection arg to see if it's a real collection
mycollections = new Collection[collections.length];
for (int i = 0; i < collections.length; i++) {
// sanity check: did handle resolve, and to a collection?
DSpaceObject dso = HandleManager.resolveToObject(context, collections[i]);
if (dso == null)
throw new IllegalArgumentException(
"Bad collection list -- "
+ "Cannot resolve collection handle \""
+ collections[i]
+ "\"");
else if (dso.getType() != Constants.COLLECTION)
throw new IllegalArgumentException(
"Bad collection list -- "
+ "Object at handle \""
+ collections[i]
+ "\" is not a collection!");
mycollections[i] = (Collection) dso;
System.out.println(
(i == 0 ? " Owning " : " ") + " Collection: " + mycollections[i].getMetadata("name"));
}
try {
// GWaller 26/08/09 Support array of collections
WorkspaceItem wi = sip.ingest(context, mycollections, source, pkgParams, null);
// GWaller 11/1/10 IssueID #157 Archive the package
InputStream sourceCopy = new FileInputStream(sourceFile);
Bundle archivedBundle =
BundleUtils.getBundleByName(wi.getItem(), Constants.ARCHIVED_CONTENT_PACKAGE_BUNDLE);
Bitstream bs = archivedBundle.createBitstream(sourceCopy);
bs.setName(new File(sourceFile).getName());
bs.update();
archivedBundle.update();
if (useWorkflow) {
String handle = null;
// Check if workflow completes immediately, and
// return Handle if so.
WorkflowItem wfi = WorkflowManager.startWithoutNotify(context, wi);
if (wfi.getState() == WorkflowManager.WFSTATE_ARCHIVE) {
Item ni = wfi.getItem();
handle = HandleManager.findHandle(context, ni);
}
if (handle == null)
System.out.println("Created Workflow item, ID=" + String.valueOf(wfi.getID()));
else System.out.println("Created and installed item, handle=" + handle);
} else {
InstallItem.installItem(context, wi);
System.out.println(
"Created and installed item, handle="
+ HandleManager.findHandle(context, wi.getItem()));
}
context.complete();
System.exit(0);
} catch (Exception e) {
// abort all operations
context.abort();
e.printStackTrace();
System.out.println(e);
System.exit(1);
}
} else {
OutputStream dest =
(sourceFile.equals("-"))
? (OutputStream) System.out
: (OutputStream) (new FileOutputStream(sourceFile));
PackageDisseminator dip =
(PackageDisseminator)
PluginManager.getNamedPlugin(PackageDisseminator.class, packageType);
if (dip == null) usageError("Error, Unknown package type: " + packageType);
DSpaceObject dso = HandleManager.resolveToObject(context, itemHandle);
if (dso == null)
throw new IllegalArgumentException(
"Bad Item handle -- " + "Cannot resolve handle \"" + itemHandle);
dip.disseminate(context, dso, pkgParams, dest);
}
}
/**
* Create new Item out of the ingested package, in the indicated collection. It creates a
* workspace item, which the application can then install if it chooses to bypass Workflow.
*
* <p>This is a VERY crude import of a single Adobe PDF (Portable Document Format) file, using the
* document's embedded metadata for package metadata. If the PDF file hasn't got the minimal
* metadata available, it is rejected.
*
* <p>
*
* @param context DSpace context.
* @param collection collection under which to create new item.
* @param pkg input stream containing package to ingest.
* @param params package parameters (none recognized)
* @param license may be null, which takes default license.
* @return workspace item created by ingest.
* @throws PackageException if package is unacceptable or there is a fatal error turning it into
* an Item.
*/
public WorkspaceItem ingest(
Context context,
Collection collection,
InputStream pkg,
PackageParameters params,
String license)
throws PackageValidationException, CrosswalkException, AuthorizeException, SQLException,
IOException {
InputStream bis = null;
COSDocument cos = null;
boolean success = false;
Bundle original = null;
Bitstream bs = null;
WorkspaceItem wi = null;
/**
* XXX comment out for now // XXX for debugging of parameter handling if (params != null) {
* Enumeration pe = params.propertyNames(); while (pe.hasMoreElements()) { String name =
* (String)pe.nextElement(); String v[] = params.getProperties(name); StringBuffer msg = new
* StringBuffer("PackageParam: "); msg.append(name).append(" = "); for (int i = 0; i < v.length;
* ++i) { if (i > 0) msg.append(", "); msg.append(v[i]); } log.debug(msg); } }
*/
try {
// Save the PDF in a bitstream first, since the parser
// has to read it as well, and we cannot "rewind" it after that.
wi = WorkspaceItem.create(context, collection, false);
Item myitem = wi.getItem();
original = myitem.createBundle("ORIGINAL");
bs = original.createBitstream(pkg);
pkg.close();
bs.setName("package.pdf");
setFormatToMIMEType(context, bs, "application/pdf");
bs.update();
log.debug("Created bitstream ID=" + String.valueOf(bs.getID()) + ", parsing...");
crosswalkPDF(context, myitem, bs.retrieve());
wi.update();
context.commit();
success = true;
log.info(
LogManager.getHeader(
context,
"ingest",
"Created new Item, db ID="
+ String.valueOf(myitem.getID())
+ ", WorkspaceItem ID="
+ String.valueOf(wi.getID())));
return wi;
} finally {
try {
// Close bitstream input stream and PDF file.
if (bis != null) bis.close();
if (cos != null) cos.close();
} catch (IOException ie) {
}
// get rid of bitstream and item if ingest fails
if (!success) {
if (original != null && bs != null) original.removeBitstream(bs);
if (wi != null) wi.deleteAll();
}
context.commit();
}
}
/**
* Process the Options to apply to the Item. The options are tab delimited
*
* <p>Options: 48217870-MIT.pdf permissions: -r 'MIT Users' description: Full printable version
* (MIT only) permissions:[r|w]-['group name'] description: 'the description of the file'
*
* <p>where: [r|w] (meaning: read|write) ['MIT Users'] (the group name)
*
* @param c
* @param myItem
* @param options
* @throws SQLException
* @throws AuthorizeException
*/
private void processOptions(Context c, Item myItem, List<String> options)
throws SQLException, AuthorizeException {
for (String line : options) {
System.out.println("\tprocessing " + line);
boolean permissionsExist = false;
boolean descriptionExists = false;
String permissionsMarker = "\tpermissions:";
int pMarkerIndex = line.indexOf(permissionsMarker);
int pEndIndex = 0;
if (pMarkerIndex > 0) {
pEndIndex = line.indexOf("\t", pMarkerIndex + 1);
if (pEndIndex == -1) {
pEndIndex = line.length();
}
permissionsExist = true;
}
String descriptionMarker = "\tdescription:";
int dMarkerIndex = line.indexOf(descriptionMarker);
int dEndIndex = 0;
if (dMarkerIndex > 0) {
dEndIndex = line.indexOf("\t", dMarkerIndex + 1);
if (dEndIndex == -1) {
dEndIndex = line.length();
}
descriptionExists = true;
}
int bsEndIndex = line.indexOf("\t");
String bitstreamName = line.substring(0, bsEndIndex);
int actionID = -1;
String groupName = "";
Group myGroup = null;
if (permissionsExist) {
String thisPermission =
line.substring(pMarkerIndex + permissionsMarker.length(), pEndIndex);
// get permission type ("read" or "write")
int pTypeIndex = thisPermission.indexOf('-');
// get permission group (should be in single quotes)
int groupIndex = thisPermission.indexOf('\'', pTypeIndex);
int groupEndIndex = thisPermission.indexOf('\'', groupIndex + 1);
// if not in single quotes, assume everything after type flag is
// group name
if (groupIndex == -1) {
groupIndex = thisPermission.indexOf(' ', pTypeIndex);
groupEndIndex = thisPermission.length();
}
groupName = thisPermission.substring(groupIndex + 1, groupEndIndex);
if (thisPermission.toLowerCase().charAt(pTypeIndex + 1) == 'r') {
actionID = Constants.READ;
} else if (thisPermission.toLowerCase().charAt(pTypeIndex + 1) == 'w') {
actionID = Constants.WRITE;
}
try {
myGroup = Group.findByName(c, groupName);
} catch (SQLException sqle) {
System.out.println("SQL Exception finding group name: " + groupName);
// do nothing, will check for null group later
}
}
String thisDescription = "";
if (descriptionExists) {
thisDescription =
line.substring(dMarkerIndex + descriptionMarker.length(), dEndIndex).trim();
}
Bitstream bs = null;
boolean notfound = true;
if (!isTest) {
// find bitstream
Bitstream[] bitstreams = myItem.getNonInternalBitstreams();
for (int j = 0; j < bitstreams.length && notfound; j++) {
if (bitstreams[j].getName().equals(bitstreamName)) {
bs = bitstreams[j];
notfound = false;
}
}
}
if (notfound && !isTest) {
// this should never happen
System.out.println("\tdefault permissions set for " + bitstreamName);
} else if (!isTest) {
if (permissionsExist) {
if (myGroup == null) {
System.out.println("\t" + groupName + " not found, permissions set to default");
} else if (actionID == -1) {
System.out.println("\tinvalid permissions flag, permissions set to default");
} else {
System.out.println("\tSetting special permissions for " + bitstreamName);
setPermission(c, myGroup, actionID, bs);
}
}
if (descriptionExists) {
System.out.println("\tSetting description for " + bitstreamName);
bs.setDescription(thisDescription);
bs.update();
}
}
}
}
/**
* Process the upload of a new file!
*
* @param context current DSpace context
* @param request current servlet request object
* @param response current servlet response object
* @param subInfo submission info object
* @return Status or error flag which will be processed by UI-related code! (if STATUS_COMPLETE or
* 0 is returned, no errors occurred!)
*/
protected int processUploadFile(
Context context,
HttpServletRequest request,
HttpServletResponse response,
SubmissionInfo subInfo)
throws ServletException, IOException, SQLException, AuthorizeException {
boolean formatKnown = true;
boolean fileOK = false;
BitstreamFormat bf = null;
Bitstream b = null;
// NOTE: File should already be uploaded.
// Manakin does this automatically via Cocoon.
// For JSP-UI, the SubmissionController.uploadFiles() does the actual upload
Enumeration attNames = request.getAttributeNames();
// loop through our request attributes
while (attNames.hasMoreElements()) {
String attr = (String) attNames.nextElement();
// if this ends with "-path", this attribute
// represents a newly uploaded file
if (attr.endsWith("-path")) {
// strip off the -path to get the actual parameter
// that the file was uploaded as
String param = attr.replace("-path", "");
// Load the file's path and input stream and description
String filePath = (String) request.getAttribute(param + "-path");
InputStream fileInputStream = (InputStream) request.getAttribute(param + "-inputstream");
// attempt to get description from attribute first, then direct from a parameter
String fileDescription = (String) request.getAttribute(param + "-description");
if (fileDescription == null || fileDescription.length() == 0) {
fileDescription = request.getParameter("description");
}
// if information wasn't passed by User Interface, we had a problem
// with the upload
if (filePath == null || fileInputStream == null) {
return STATUS_UPLOAD_ERROR;
}
if (subInfo == null) {
// In any event, if we don't have the submission info, the request
// was malformed
return STATUS_INTEGRITY_ERROR;
}
// Create the bitstream
Item item = subInfo.getSubmissionItem().getItem();
// do we already have a bundle?
Bundle[] bundles = item.getBundles("ORIGINAL");
if (bundles.length < 1) {
// set bundle's name to ORIGINAL
b = item.createSingleBitstream(fileInputStream, "ORIGINAL");
} else {
// we have a bundle already, just add bitstream
b = bundles[0].createBitstream(fileInputStream);
}
// Strip all but the last filename. It would be nice
// to know which OS the file came from.
String noPath = filePath;
while (noPath.indexOf('/') > -1) {
noPath = noPath.substring(noPath.indexOf('/') + 1);
}
while (noPath.indexOf('\\') > -1) {
noPath = noPath.substring(noPath.indexOf('\\') + 1);
}
b.setName(noPath);
b.setSource(filePath);
b.setDescription(fileDescription);
// Identify the format
bf = FormatIdentifier.guessFormat(context, b);
b.setFormat(bf);
// Update to DB
b.update();
item.update();
if ((bf != null) && (bf.isInternal())) {
log.warn("Attempt to upload file format marked as internal system use only");
backoutBitstream(subInfo, b, item);
return STATUS_UPLOAD_ERROR;
}
// Check for virus
if (ConfigurationManager.getBooleanProperty("submission-curation", "virus-scan")) {
Curator curator = new Curator();
curator.addTask("vscan").curate(item);
int status = curator.getStatus("vscan");
if (status == Curator.CURATE_ERROR) {
backoutBitstream(subInfo, b, item);
return STATUS_VIRUS_CHECKER_UNAVAILABLE;
} else if (status == Curator.CURATE_FAIL) {
backoutBitstream(subInfo, b, item);
return STATUS_CONTAINS_VIRUS;
}
}
// If we got this far then everything is more or less ok.
// Comment - not sure if this is the right place for a commit here
// but I'm not brave enough to remove it - Robin.
context.commit();
// save this bitstream to the submission info, as the
// bitstream we're currently working with
subInfo.setBitstream(b);
// if format was not identified
if (bf == null) {
return STATUS_UNKNOWN_FORMAT;
}
} // end if attribute ends with "-path"
} // end while
return STATUS_COMPLETE;
}
