mirror of
https://github.com/DSpace/DSpace.git
synced 2025-10-14 13:33:08 +00:00
391 lines
12 KiB
Java
391 lines
12 KiB
Java
/**
|
|
* 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.license;
|
|
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.StringWriter;
|
|
import java.sql.SQLException;
|
|
import java.util.List;
|
|
|
|
import javax.xml.transform.Templates;
|
|
import javax.xml.transform.TransformerConfigurationException;
|
|
import javax.xml.transform.TransformerException;
|
|
import javax.xml.transform.TransformerFactory;
|
|
import javax.xml.transform.stream.StreamResult;
|
|
import javax.xml.transform.stream.StreamSource;
|
|
|
|
import org.apache.commons.lang.StringUtils;
|
|
import org.apache.log4j.Logger;
|
|
import org.dspace.authorize.AuthorizeException;
|
|
import org.dspace.content.Bitstream;
|
|
import org.dspace.content.BitstreamFormat;
|
|
import org.dspace.content.Bundle;
|
|
import org.dspace.content.Item;
|
|
import org.dspace.content.service.BitstreamFormatService;
|
|
import org.dspace.content.service.BitstreamService;
|
|
import org.dspace.content.service.BundleService;
|
|
import org.dspace.content.service.ItemService;
|
|
import org.dspace.core.ConfigurationManager;
|
|
import org.dspace.core.Context;
|
|
import org.dspace.core.Utils;
|
|
import org.dspace.license.service.CreativeCommonsService;
|
|
import org.dspace.services.ConfigurationService;
|
|
import org.dspace.services.factory.DSpaceServicesFactory;
|
|
import org.jdom.Document;
|
|
import org.jdom.transform.JDOMSource;
|
|
import org.springframework.beans.factory.InitializingBean;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
|
|
public class CreativeCommonsServiceImpl implements CreativeCommonsService, InitializingBean
|
|
{
|
|
/** log4j category */
|
|
private static Logger log = Logger.getLogger(CreativeCommonsServiceImpl.class);
|
|
|
|
/**
|
|
* The Bundle Name
|
|
*/
|
|
|
|
protected static final String CC_BS_SOURCE = "org.dspace.license.CreativeCommons";
|
|
|
|
/**
|
|
* Some BitStream Names (BSN)
|
|
*/
|
|
@Deprecated
|
|
protected static final String BSN_LICENSE_URL = "license_url";
|
|
|
|
@Deprecated
|
|
protected static final String BSN_LICENSE_TEXT = "license_text";
|
|
|
|
protected static final String BSN_LICENSE_RDF = "license_rdf";
|
|
|
|
protected Templates templates;
|
|
|
|
@Autowired(required = true)
|
|
protected BitstreamService bitstreamService;
|
|
@Autowired(required = true)
|
|
protected BitstreamFormatService bitstreamFormatService;
|
|
@Autowired(required = true)
|
|
protected BundleService bundleService;
|
|
@Autowired(required = true)
|
|
protected ItemService itemService;
|
|
|
|
protected ConfigurationService configurationService = DSpaceServicesFactory.getInstance().getConfigurationService();
|
|
|
|
protected CreativeCommonsServiceImpl()
|
|
{
|
|
|
|
}
|
|
|
|
@Override
|
|
public void afterPropertiesSet() throws Exception
|
|
{
|
|
// if defined, set a proxy server for http requests to Creative
|
|
// Commons site
|
|
String proxyHost = configurationService.getProperty("http.proxy.host");
|
|
String proxyPort = configurationService.getProperty("http.proxy.port");
|
|
|
|
if (StringUtils.isNotBlank(proxyHost) && StringUtils.isNotBlank(proxyPort))
|
|
{
|
|
System.setProperty("http.proxyHost", proxyHost);
|
|
System.setProperty("http.proxyPort", proxyPort);
|
|
}
|
|
|
|
try
|
|
{
|
|
templates = TransformerFactory.newInstance().newTemplates(
|
|
new StreamSource(CreativeCommonsServiceImpl.class
|
|
.getResourceAsStream("CreativeCommons.xsl")));
|
|
}
|
|
catch (TransformerConfigurationException e)
|
|
{
|
|
throw new RuntimeException(e.getMessage(),e);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
@Override
|
|
public boolean isEnabled()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// create the CC bundle if it doesn't exist
|
|
// If it does, remove it and create a new one.
|
|
protected Bundle getCcBundle(Context context, Item item)
|
|
throws SQLException, AuthorizeException, IOException
|
|
{
|
|
List<Bundle> bundles = itemService.getBundles(item, CC_BUNDLE_NAME);
|
|
|
|
if ((bundles.size() > 0) && (bundles.get(0) != null))
|
|
{
|
|
itemService.removeBundle(context, item, bundles.get(0));
|
|
}
|
|
return bundleService.create(context, item, CC_BUNDLE_NAME);
|
|
}
|
|
|
|
@Override
|
|
public void setLicenseRDF(Context context, Item item, String licenseRdf)
|
|
throws SQLException, IOException,
|
|
AuthorizeException
|
|
{
|
|
Bundle bundle = getCcBundle(context, item);
|
|
// set the format
|
|
BitstreamFormat bs_rdf_format = bitstreamFormatService.findByShortDescription(context, "RDF XML");
|
|
// set the RDF bitstream
|
|
setBitstreamFromBytes(context, item, bundle, BSN_LICENSE_RDF, bs_rdf_format, licenseRdf.getBytes());
|
|
}
|
|
|
|
|
|
@Override
|
|
public void setLicense(Context context, Item item,
|
|
InputStream licenseStm, String mimeType)
|
|
throws SQLException, IOException, AuthorizeException
|
|
{
|
|
Bundle bundle = getCcBundle(context, item);
|
|
|
|
// set the format
|
|
BitstreamFormat bs_format;
|
|
if (mimeType.equalsIgnoreCase("text/xml"))
|
|
{
|
|
bs_format = bitstreamFormatService.findByShortDescription(context, "CC License");
|
|
} else if (mimeType.equalsIgnoreCase("text/rdf")) {
|
|
bs_format = bitstreamFormatService.findByShortDescription(context, "RDF XML");
|
|
} else {
|
|
bs_format = bitstreamFormatService.findByShortDescription(context, "License");
|
|
}
|
|
|
|
Bitstream bs = bitstreamService.create(context, bundle, licenseStm);
|
|
bs.setSource(context, CC_BS_SOURCE);
|
|
bs.setName(context, (mimeType != null &&
|
|
(mimeType.equalsIgnoreCase("text/xml") ||
|
|
mimeType.equalsIgnoreCase("text/rdf"))) ?
|
|
BSN_LICENSE_RDF : BSN_LICENSE_TEXT);
|
|
bs.setFormat(context, bs_format);
|
|
bitstreamService.update(context, bs);
|
|
}
|
|
|
|
|
|
@Override
|
|
public void removeLicense(Context context, Item item)
|
|
throws SQLException, IOException, AuthorizeException
|
|
{
|
|
// remove CC license bundle if one exists
|
|
List<Bundle> bundles = itemService.getBundles(item, CC_BUNDLE_NAME);
|
|
|
|
if ((bundles.size() > 0) && (bundles.get(0) != null))
|
|
{
|
|
itemService.removeBundle(context, item, bundles.get(0));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean hasLicense(Context context, Item item)
|
|
throws SQLException, IOException
|
|
{
|
|
// try to find CC license bundle
|
|
List<Bundle> bundles = itemService.getBundles(item, CC_BUNDLE_NAME);
|
|
|
|
if (bundles.size() == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// verify it has correct contents
|
|
try
|
|
{
|
|
if ((getLicenseURL(context, item) == null))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
catch (AuthorizeException ae)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public String getLicenseRDF(Context context, Item item) throws SQLException,
|
|
IOException, AuthorizeException
|
|
{
|
|
return getStringFromBitstream(context, item, BSN_LICENSE_RDF);
|
|
}
|
|
|
|
@Override
|
|
public Bitstream getLicenseRdfBitstream(Item item) throws SQLException,
|
|
IOException, AuthorizeException
|
|
{
|
|
return getBitstream(item, BSN_LICENSE_RDF);
|
|
}
|
|
|
|
@Deprecated
|
|
@Override
|
|
public Bitstream getLicenseTextBitstream(Item item) throws SQLException,
|
|
IOException, AuthorizeException
|
|
{
|
|
return getBitstream(item, BSN_LICENSE_TEXT);
|
|
}
|
|
|
|
@Override
|
|
public String getLicenseURL(Context context, Item item) throws SQLException, IOException, AuthorizeException {
|
|
String licenseUri = getCCField("uri").ccItemValue(item);
|
|
if (StringUtils.isNotBlank(licenseUri)) {
|
|
return licenseUri;
|
|
}
|
|
|
|
//backward compatibility
|
|
return getStringFromBitstream(context, item, BSN_LICENSE_URL);
|
|
}
|
|
|
|
@Override
|
|
public String fetchLicenseRDF(Document license)
|
|
{
|
|
StringWriter result = new StringWriter();
|
|
|
|
try
|
|
{
|
|
templates.newTransformer().transform(
|
|
new JDOMSource(license),
|
|
new StreamResult(result)
|
|
);
|
|
}
|
|
catch (TransformerException e)
|
|
{
|
|
throw new IllegalStateException(e.getMessage(),e);
|
|
}
|
|
|
|
return result.getBuffer().toString();
|
|
}
|
|
|
|
// The following two helper methods assume that the CC
|
|
// bitstreams are short and easily expressed as byte arrays in RAM
|
|
|
|
/**
|
|
* This helper method takes some bytes and stores them as a bitstream for an
|
|
* item, under the CC bundle, with the given bitstream name
|
|
*/
|
|
protected void setBitstreamFromBytes(Context context, Item item, Bundle bundle,
|
|
String bitstream_name, BitstreamFormat format, byte[] bytes)
|
|
throws SQLException, IOException, AuthorizeException
|
|
{
|
|
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
|
|
Bitstream bs = bitstreamService.create(context, bundle, bais);
|
|
|
|
bs.setName(context, bitstream_name);
|
|
bs.setSource(context, CC_BS_SOURCE);
|
|
bs.setFormat(context, format);
|
|
|
|
// commit everything
|
|
bitstreamService.update(context, bs);
|
|
}
|
|
|
|
/**
|
|
* This helper method wraps a String around a byte array returned from the
|
|
* bitstream method further down
|
|
*/
|
|
protected String getStringFromBitstream(Context context, Item item,
|
|
String bitstream_name) throws SQLException, IOException,
|
|
AuthorizeException
|
|
{
|
|
byte[] bytes = getBytesFromBitstream(context, item, bitstream_name);
|
|
|
|
if (bytes == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return new String(bytes);
|
|
}
|
|
|
|
/**
|
|
* This helper method retrieves the bytes of a bitstream for an item under
|
|
* the CC bundle, with the given bitstream name
|
|
*/
|
|
protected Bitstream getBitstream(Item item, String bitstream_name)
|
|
throws SQLException, IOException, AuthorizeException
|
|
{
|
|
Bundle cc_bundle = null;
|
|
|
|
// look for the CC bundle
|
|
try
|
|
{
|
|
List<Bundle> bundles = itemService.getBundles(item, CC_BUNDLE_NAME);
|
|
|
|
if ((bundles != null) && (bundles.size() > 0))
|
|
{
|
|
cc_bundle = bundles.get(0);
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
// this exception catching is a bit generic,
|
|
// but basically it happens if there is no CC bundle
|
|
return null;
|
|
}
|
|
|
|
return bundleService.getBitstreamByName(cc_bundle, bitstream_name);
|
|
}
|
|
|
|
protected byte[] getBytesFromBitstream(Context context, Item item, String bitstream_name)
|
|
throws SQLException, IOException, AuthorizeException
|
|
{
|
|
Bitstream bs = getBitstream(item, bitstream_name);
|
|
|
|
// no such bitstream
|
|
if (bs == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// create a ByteArrayOutputStream
|
|
ByteArrayOutputStream baos = new ByteArrayOutputStream();
|
|
Utils.copy(bitstreamService.retrieve(context, bs), baos);
|
|
|
|
return baos.toByteArray();
|
|
}
|
|
|
|
/**
|
|
* Returns a metadata field handle for given field Id
|
|
*/
|
|
@Override
|
|
public LicenseMetadataValue getCCField(String fieldId)
|
|
{
|
|
return new LicenseMetadataValue(configurationService.getProperty("cc.license." + fieldId));
|
|
}
|
|
|
|
@Override
|
|
public void removeLicense(Context context, LicenseMetadataValue uriField,
|
|
LicenseMetadataValue nameField, Item item) throws AuthorizeException, IOException, SQLException {
|
|
// only remove any previous licenses
|
|
String licenseUri = uriField.ccItemValue(item);
|
|
if (licenseUri != null) {
|
|
uriField.removeItemValue(context, item, licenseUri);
|
|
if (configurationService.getBooleanProperty("cc.submit.setname"))
|
|
{
|
|
String licenseName = nameField.keyedItemValue(item, licenseUri);
|
|
nameField.removeItemValue(context, item, licenseName);
|
|
}
|
|
if (configurationService.getBooleanProperty("cc.submit.addbitstream"))
|
|
{
|
|
removeLicense(context, item);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|