/**
* 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.rdf.conversion;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.util.FileManager;
import com.hp.hpl.jena.util.FileUtils;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;
import org.apache.log4j.Logger;
import org.dspace.content.DSpaceObject;
import org.dspace.content.factory.ContentServiceFactory;
import org.dspace.core.Constants;
import org.dspace.core.Context;
import org.dspace.rdf.RDFUtil;
import org.dspace.services.ConfigurationService;
import org.springframework.beans.factory.annotation.Autowired;
/**
*
* @author Pascal-Nicolas Becker (dspace -at- pascal -hyphen- becker -dot- de)
*/
public class StaticDSOConverterPlugin
implements ConverterPlugin
{
private static final Logger log = Logger.getLogger(StaticDSOConverterPlugin.class);
public static final String CONSTANT_DATA_FILENAME_KEY_PREFIX = "rdf.constant.data.";
public static final String CONSTANT_DATA_GENERAL_KEY_SUFFIX = "GENERAL";
@Autowired(required=true)
protected ConfigurationService configurationService;
@Override
public void setConfigurationService(ConfigurationService configurationService) {
this.configurationService = configurationService;
}
@Override
public Model convert(Context context, DSpaceObject dso)
throws SQLException
{
// As we do not use data of any DSpaceObject, we do not have to check
// permissions here. We provide only static data out of configuration
// files.
Model general = this.readFile(CONSTANT_DATA_GENERAL_KEY_SUFFIX,
RDFUtil.generateIdentifier(context, dso));
Model typeSpecific = this.readFile(ContentServiceFactory.getInstance().getDSpaceObjectService(dso).getTypeText(dso),
RDFUtil.generateIdentifier(context, dso));
if (general == null)
return typeSpecific;
if (typeSpecific == null)
return general;
typeSpecific.setNsPrefixes(general);
typeSpecific.add(general);
general.close();
return typeSpecific;
}
protected Model readFile(String fileSuffix, String base)
{
String path = configurationService.getProperty(
CONSTANT_DATA_FILENAME_KEY_PREFIX + fileSuffix);
if (path == null)
{
log.error("Cannot find dspace-rdf configuration (looking for "
+ "property " + CONSTANT_DATA_FILENAME_KEY_PREFIX
+ fileSuffix + ")!");
throw new RuntimeException("Cannot find dspace-rdf configuration "
+ "(looking for property " +
CONSTANT_DATA_FILENAME_KEY_PREFIX + fileSuffix + ")!");
}
log.debug("Going to read static data from file '" + path + "'.");
InputStream is = null;
Model staticDataModel = null;
try {
is = FileManager.get().open(path);
if (is == null)
{
log.warn("StaticDSOConverterPlugin cannot find file '" + path
+ "', ignoring...");
return null;
}
staticDataModel = ModelFactory.createDefaultModel();
staticDataModel.read(is, base, FileUtils.guessLang(path));
} finally {
if (is != null)
{
try {
is.close();
}
catch (IOException ex)
{
// nothing to do here.
}
}
}
if (staticDataModel.isEmpty())
{
staticDataModel.close();
return null;
}
return staticDataModel;
}
@Override
public boolean supports(int type)
{
switch (type)
{
case (Constants.COLLECTION) :
return true;
case (Constants.COMMUNITY) :
return true;
case (Constants.ITEM) :
return true;
case (Constants.SITE) :
return true;
default :
return false;
}
}
}