/** Set the content type that DSpace received. */
protected void addContentElement() throws DSpaceSWORDException {
try {
// get the things we need out of the service
SWORDUrlManager urlManager = swordService.getUrlManager();
// if this is a deposit which is no op we can't do anything here
if (this.deposit != null && this.deposit.isNoOp()) {
return;
}
String bsurl = urlManager.getBitstreamUrl(this.bitstream);
BitstreamFormat bf = null;
try {
bf = this.bitstream.getFormat(swordService.getContext());
} catch (SQLException e) {
log.error("Exception caught: ", e);
throw new DSpaceSWORDException(e);
}
String format = "application/octet-stream";
if (bf != null) {
format = bf.getMIMEType();
}
Content con = new Content();
con.setType(format);
con.setSource(bsurl);
entry.setContent(con);
log.debug("Adding content element with url=" + bsurl);
} catch (InvalidMediaTypeException e) {
log.error("caught and swallowed exception: ", e);
// do nothing; we'll live without the content type declaration!
}
}
/** Add links associated with this item. */
protected void addLinks() throws DSpaceSWORDException {
// if this is a deposit which is no op we can't do anything here
if (this.deposit != null && this.deposit.isNoOp()) {
return;
}
// get the things we need out of the service
SWORDUrlManager urlManager = swordService.getUrlManager();
String bsurl = urlManager.getBitstreamUrl(this.bitstream);
BitstreamFormat bf;
try {
bf = this.bitstream.getFormat(swordService.getContext());
} catch (SQLException e) {
log.error("Exception caught: ", e);
throw new DSpaceSWORDException(e);
}
String format = "application/octet-stream";
if (bf != null) {
format = bf.getMIMEType();
}
Link link = new Link();
link.setType(format);
link.setHref(bsurl);
link.setRel("alternate");
entry.addLink(link);
log.debug("Added link entity to entry for url " + bsurl);
}
/** Add rights information. This attaches an href to the URL of the item's licence file */
protected void addRights() throws DSpaceSWORDException {
try {
// work our way up to the item
List<Bundle> bundle2bitstreams = this.bitstream.getBundles();
if (bundle2bitstreams.isEmpty()) {
log.error("Found orphaned bitstream: " + bitstream.getID());
throw new DSpaceSWORDException("Orphaned bitstream discovered");
}
Bundle bundle = bundle2bitstreams.get(0);
List<Item> items = bundle.getItems();
if (items.isEmpty()) {
log.error("Found orphaned bundle: " + bundle.getID());
throw new DSpaceSWORDException("Orphaned bundle discovered");
}
Item item = items.get(0);
// now get the licence out of the item
SWORDUrlManager urlManager = swordService.getUrlManager();
StringBuilder rightsString = new StringBuilder();
List<Bundle> lbundles = item.getBundles();
for (Bundle lbundle : lbundles) {
if (!Constants.LICENSE_BUNDLE_NAME.equals(lbundle.getName())) {
// skip non-license bundles
continue;
}
List<Bitstream> bss = lbundle.getBitstreams();
for (Bitstream bs : bss) {
String url = urlManager.getBitstreamUrl(bs);
rightsString.append(url).append(" ");
}
}
Rights rights = new Rights();
rights.setContent(rightsString.toString());
rights.setType(ContentType.TEXT);
entry.setRights(rights);
log.debug("Added rights entry to entity");
} catch (SQLException e) {
log.error("caught exception: ", e);
throw new DSpaceSWORDException(e);
}
}
/**
* Add the identifier for the item. If the item object has a handle already assigned, this is
* used, otherwise, the passed handle is used. It is set in the form that they can be used to
* access the resource over http (i.e. a real URL).
*/
protected void addIdentifier() throws DSpaceSWORDException {
// if this is a deposit which is no op we can't do anything here
if (this.deposit != null && this.deposit.isNoOp()) {
// just use the dspace url as the
// property
String cfg = ConfigurationManager.getProperty("dspace.url");
entry.setId(cfg);
return;
}
SWORDUrlManager urlManager = swordService.getUrlManager();
// for a bitstream, we just use the url for the bitstream
// as the identifier
String bsurl = urlManager.getBitstreamUrl(this.bitstream);
entry.setId(bsurl);
log.debug("Added identifier for bitstream with url=" + bsurl);
return;
// FIXME: later on we will maybe have a workflow page supplied
// by the sword interface?
}
/**
* 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);
}
}
