/**
* 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 use the metadata retrieved at {@link CreativeCommonsService#getCCField(String)} (see https://jira.duraspace.org/browse/DS-2604)
*/
@Deprecated
protected static final String BSN_LICENSE_URL = "license_url";
/**
* @deprecated to make uniform JSPUI and XMLUI approach the bitstream with the license in the textual format it is no longer stored (see https://jira.duraspace.org/browse/DS-2604)
*/
@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;
}
// JSPUI backward compatibility see https://jira.duraspace.org/browse/DS-2604
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();
}
/**
* This helper method takes some bytes and stores them as a bitstream for an
* item, under the CC bundle, with the given bitstream name
*
* Note: This helper method assumes that the CC
* bitstreams are short and easily expressed as byte arrays in RAM
*
* @param context
* The relevant DSpace Context.
* @param item
* parent item
* @param bundle
* parent bundle
* @param bitstream_name
* bitstream name to set
* @param format
* bitstream format
* @param bytes
* bitstream data
* @throws IOException
* A general class of exceptions produced by failed or interrupted I/O operations.
* @throws SQLException
* An exception that provides information on a database access error or other errors.
* @throws AuthorizeException
* Exception indicating the current user of the context does not have permission
* to perform a particular action.
*/
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
*
* Note: This helper method assumes that the CC
* bitstreams are short and easily expressed as byte arrays in RAM
*
* @param context
* The relevant DSpace Context.
* @param item
* parent item
* @param bitstream_name
* bitstream name to set
* @return the bitstream as string
* @throws IOException
* A general class of exceptions produced by failed or interrupted I/O operations.
* @throws SQLException
* An exception that provides information on a database access error or other errors.
* @throws AuthorizeException
* Exception indicating the current user of the context does not have permission
* to perform a particular action.
*/
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
*
* @param item
* parent item
* @param bitstream_name
* bitstream name to set
* @return the bitstream
* @throws IOException
* A general class of exceptions produced by failed or interrupted I/O operations.
* @throws SQLException
* An exception that provides information on a database access error or other errors.
* @throws AuthorizeException
* Exception indicating the current user of the context does not have permission
* to perform a particular action.
*/
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);
}
}
}
}