org.dspace.identifier.DOIIdentifierProvider Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of dspace-api Show documentation
Show all versions of dspace-api Show documentation
DSpace core data model and service APIs.
The newest version!
/**
* 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.identifier;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.dspace.authorize.AuthorizeException;
import org.dspace.content.DSpaceObject;
import org.dspace.content.Item;
import org.dspace.content.MetadataValue;
import org.dspace.content.factory.ContentServiceFactory;
import org.dspace.content.logic.Filter;
import org.dspace.content.logic.LogicalStatementException;
import org.dspace.content.logic.TrueFilter;
import org.dspace.content.service.ItemService;
import org.dspace.core.Constants;
import org.dspace.core.Context;
import org.dspace.identifier.doi.DOIConnector;
import org.dspace.identifier.doi.DOIIdentifierException;
import org.dspace.identifier.doi.DOIIdentifierNotApplicableException;
import org.dspace.identifier.service.DOIService;
import org.dspace.services.factory.DSpaceServicesFactory;
import org.springframework.beans.factory.annotation.Autowired;
/**
* Provide service for DOIs using DataCite.
*
* This class handles reservation, registration and deletion of DOIs using
* the direct API from DataCite.
* Please pay attention that some members of DataCite offer special services
* and want their customers to use special APIs. If you are unsure ask your
* registration agency.
*
* Any identifier a method of this class returns is a string in the following format: doi:10.123/456.
*
* @author Pascal-Nicolas Becker
* @author Kim Shepherd
*/
public class DOIIdentifierProvider extends FilteredIdentifierProvider {
private static final Logger log = LogManager.getLogger();
/**
* A DOIConnector connects the DOIIdentifierProvider to the API of the DOI
* registration agency needed to register DOIs. To register DOIs we have to
* care about two APIs: the IdentifierProvider API of DSpace
* and the API of the DOI registration agency. The DOIIdentifierProvider
* manages the DOI database table, generates new DOIs, stores them as
* metadata in DSpace items and so on. To register DOIs at DOI registration
* agencies it uses a DOIConnector. A DOI connector has to register and
* reserve DOIs using the API of the DOI registration agency. If requested
* by the registration agency it has to convert and send metadata of the
* DSpace items.
*/
private DOIConnector connector;
static final String CFG_PREFIX = "identifier.doi.prefix";
static final String CFG_NAMESPACE_SEPARATOR = "identifier.doi.namespaceseparator";
static final char SLASH = '/';
// Metadata field name elements
// TODO: move these to MetadataSchema or some such?
public static final String MD_SCHEMA = "dc";
public static final String DOI_ELEMENT = "identifier";
public static final String DOI_QUALIFIER = "uri";
// The DOI is queued for registered with the service provider
public static final Integer TO_BE_REGISTERED = 1;
// The DOI is queued for reservation with the service provider
public static final Integer TO_BE_RESERVED = 2;
// The DOI has been registered online
public static final Integer IS_REGISTERED = 3;
// The DOI has been reserved online
public static final Integer IS_RESERVED = 4;
// The DOI is reserved and requires an updated metadata record to be sent to the service provider
public static final Integer UPDATE_RESERVED = 5;
// The DOI is registered and requires an updated metadata record to be sent to the service provider
public static final Integer UPDATE_REGISTERED = 6;
// The DOI metadata record should be updated before performing online registration
public static final Integer UPDATE_BEFORE_REGISTRATION = 7;
// The DOI will be deleted locally and marked as deleted in the DOI service provider
public static final Integer TO_BE_DELETED = 8;
// The DOI has been deleted and is no longer associated with an item
public static final Integer DELETED = 9;
// The DOI is created in the database and is waiting for either successful filter check on item install or
// manual intervention by an administrator to proceed to reservation or registration
public static final Integer PENDING = 10;
// The DOI is created in the database, but no more context is known
public static final Integer MINTED = 11;
public static final String[] statusText = {
"UNKNOWN", // 0
"TO_BE_REGISTERED", // 1
"TO_BE_RESERVED", // 2
"IS_REGISTERED", // 3
"IS_RESERVED", // 4
"UPDATE_RESERVED", // 5
"UPDATE_REGISTERED", // 6
"UPDATE_BEFORE_REGISTRATION", // 7
"TO_BE_DELETED", // 8
"DELETED", // 9
"PENDING", // 10
"MINTED", // 11
};
@Autowired(required = true)
protected DOIService doiService;
@Autowired(required = true)
protected ContentServiceFactory contentServiceFactory;
@Autowired(required = true)
protected ItemService itemService;
/**
* Empty / default constructor for Spring
*/
protected DOIIdentifierProvider() {
}
/**
* Prefix of DOI namespace. Set in dspace.cfg.
*/
private String PREFIX;
/**
* Part of DOI to separate several applications that generate DOIs.
* E.g. it could be 'dspace/' if DOIs generated by DSpace should have the form
* prefix/dspace/uniqueString. Set it to the empty String if DSpace must
* generate DOIs directly after the DOI Prefix. Set in dspace.cfg.
*/
private String NAMESPACE_SEPARATOR;
/**
* Get DOI prefix from configuration
* @return a String containing the DOI prefix
*/
protected String getPrefix() {
if (null == this.PREFIX) {
this.PREFIX = this.configurationService.getProperty(CFG_PREFIX);
if (null == this.PREFIX) {
log.warn("Cannot find DOI prefix in configuration!");
throw new RuntimeException("Unable to load DOI prefix from "
+ "configuration. Cannot find property " +
CFG_PREFIX + ".");
}
}
return this.PREFIX;
}
/**
* Get namespace separator from configuration
* @return a String containing the namespace separator
*/
protected String getNamespaceSeparator() {
if (null == this.NAMESPACE_SEPARATOR) {
this.NAMESPACE_SEPARATOR = this.configurationService.getProperty(CFG_NAMESPACE_SEPARATOR);
if (null == this.NAMESPACE_SEPARATOR) {
this.NAMESPACE_SEPARATOR = "";
}
}
return this.NAMESPACE_SEPARATOR;
}
/**
* Set the DOI connector, which is the component that commuincates with the remote registration service
* (eg. DataCite, EZID, Crossref)
* Spring will use this setter to set the DOI connector from the configured property in identifier-services.xml
*
* @param connector a DOIConnector
*/
@Autowired(required = true)
public void setDOIConnector(DOIConnector connector) {
this.connector = connector;
}
/**
* This identifier provider supports identifiers of type
* {@link org.dspace.identifier.DOI}.
*
* @param identifier to check if it will be supported by this provider.
* @return boolean
*/
@Override
public boolean supports(Class identifier) {
return DOI.class.isAssignableFrom(identifier);
}
/**
* This identifier provider supports identifiers in the following format:
*
* - doi:10.123/456
* - 10.123/456
* - http://dx.doi.org/10.123/456
*
*
* @param identifier to check if it is in a supported format.
* @return boolean
*/
@Override
public boolean supports(String identifier) {
try {
doiService.formatIdentifier(identifier);
} catch (IdentifierException | IllegalArgumentException ex) {
return false;
}
return true;
}
/**
* Register a new identifier for a given DSpaceObject, never skipping or ignoring any configured filter
* @param context - DSpace context
* @param dso - DSpaceObject to use for identifier registration
* @return identifier
* @throws IdentifierException
*/
@Override
public String register(Context context, DSpaceObject dso)
throws IdentifierException {
return register(context, dso, this.filter);
}
/**
* Register a specified DOI for a given DSpaceObject, never skipping or ignoring any configured filter
* @param context - DSpace context
* @param dso - DSpaceObject identified by the new DOI
* @param identifier - String containing the identifier to register
* @throws IdentifierException
*/
@Override
public void register(Context context, DSpaceObject dso, String identifier)
throws IdentifierException {
register(context, dso, identifier, this.filter);
}
/**
* Register a new DOI for a given DSpaceObject
* @param context - DSpace context
* @param dso - DSpaceObject identified by the new DOI
* @param filter - Logical item filter to determine whether this identifier should be registered
* @throws IdentifierException
*/
@Override
public String register(Context context, DSpaceObject dso, Filter filter)
throws IdentifierException {
if (!(dso instanceof Item)) {
// DOI are currently assigned only to Item
return null;
}
String doi = mint(context, dso, filter);
// register tries to reserve doi if it's not already.
// So we don't have to reserve it here.
register(context, dso, doi, filter);
return doi;
}
/**
* Register a specified DOI for a given DSpaceObject
* @param context - DSpace context
* @param dso - DSpaceObject identified by the new DOI
* @param identifier - String containing the DOI to register
* @param filter - Logical item filter to determine whether this identifier should be registered
* @throws IdentifierException
*/
@Override
public void register(Context context, DSpaceObject dso, String identifier, Filter filter)
throws IdentifierException {
if (!(dso instanceof Item)) {
// DOI are currently assigned only to Item
return;
}
String doi = doiService.formatIdentifier(identifier);
DOI doiRow = null;
// search DOI in our db
try {
doiRow = loadOrCreateDOI(context, dso, doi, filter);
} catch (SQLException ex) {
log.error("Error in database connection: {}", ex::getMessage);
throw new RuntimeException("Error in database connection.", ex);
}
if (DELETED.equals(doiRow.getStatus()) ||
TO_BE_DELETED.equals(doiRow.getStatus())) {
throw new DOIIdentifierException("You tried to register a DOI that "
+ "is marked as DELETED.", DOIIdentifierException.DOI_IS_DELETED);
}
if (IS_REGISTERED.equals(doiRow.getStatus())) {
return;
}
// change status of DOI
doiRow.setStatus(TO_BE_REGISTERED);
try {
doiService.update(context, doiRow);
} catch (SQLException sqle) {
log.warn("SQLException while changing status of DOI {} to be registered.", doi);
throw new RuntimeException(sqle);
}
}
/**
* @param context The relevant DSpace Context.
* @param dso DSpaceObject the DOI should be reserved for. Some metadata of
* this object will be send to the registration agency.
* @param identifier DOI to register in a format that
* {@link org.dspace.identifier.service.DOIService#formatIdentifier(String)} accepts.
* @throws IdentifierException If the format of {@code identifier} was
* unrecognized or if it was impossible to
* reserve the DOI (registration agency denied
* for some reason, see logs).
* @throws IllegalArgumentException If {@code identifier} is a DOI already
* registered for another DSpaceObject then {@code dso}.
* @see org.dspace.identifier.IdentifierProvider#reserve(Context, DSpaceObject, String)
*/
@Override
public void reserve(Context context, DSpaceObject dso, String identifier)
throws IdentifierException, IllegalArgumentException {
reserve(context, dso, identifier, this.filter);
}
/**
* Reserve a specified DOI for a given DSpaceObject
* @param context - DSpace context
* @param dso - DSpaceObject identified by this DOI
* @param identifier - String containing the DOI to reserve
* @param filter - Logical item filter to determine whether this identifier should be reserved
* @throws IdentifierException
* @throws IllegalArgumentException
*/
@Override
public void reserve(Context context, DSpaceObject dso, String identifier, Filter filter)
throws IdentifierException, IllegalArgumentException {
String doi = doiService.formatIdentifier(identifier);
DOI doiRow = null;
try {
doiRow = loadOrCreateDOI(context, dso, doi, filter);
} catch (SQLException sqle) {
throw new RuntimeException(sqle);
}
if (doiRow.getStatus() != null) {
return;
}
doiRow.setStatus(TO_BE_RESERVED);
try {
doiService.update(context, doiRow);
} catch (SQLException sqle) {
throw new RuntimeException(sqle);
}
}
/**
* Perform the actual online / API interaction required to reserve the DOI online
* always applying filters if they are configured
* @param context - DSpace context
* @param dso - DSpaceObject identified by this DOI
* @param identifier - String containing the DOI to reserve
* @throws IdentifierException
* @throws IllegalArgumentException
* @throws SQLException
*/
public void reserveOnline(Context context, DSpaceObject dso, String identifier)
throws IdentifierException, IllegalArgumentException, SQLException {
reserveOnline(context, dso, identifier, this.filter);
}
/**
* Perform the actual online / API interaction required to reserve the DOI online
* @param context - DSpace context
* @param dso - DSpaceObject identified by this DOI
* @param identifier - String containing the DOI to reserve
* @param filter - Logical item filter to determine whether this identifier should be reserved online
* @throws IdentifierException
* @throws IllegalArgumentException
* @throws SQLException
*/
public void reserveOnline(Context context, DSpaceObject dso, String identifier, Filter filter)
throws IdentifierException, IllegalArgumentException, SQLException {
String doi = doiService.formatIdentifier(identifier);
// get TableRow and ensure DOI belongs to dso regarding our db
DOI doiRow = loadOrCreateDOI(context, dso, doi, filter);
if (DELETED.equals(doiRow.getStatus()) || TO_BE_DELETED.equals(doiRow.getStatus())) {
throw new DOIIdentifierException("You tried to reserve a DOI that "
+ "is marked as DELETED.", DOIIdentifierException.DOI_IS_DELETED);
}
connector.reserveDOI(context, dso, doi);
doiRow.setStatus(IS_RESERVED);
doiService.update(context, doiRow);
}
/**
* Perform the actual online / API interaction required to register the DOI online
* always applying filters if they are configured
* @param context - DSpace context
* @param dso - DSpaceObject identified by this DOI
* @param identifier - String containing the DOI to register
* @throws IdentifierException
* @throws IllegalArgumentException
* @throws SQLException
*/
public void registerOnline(Context context, DSpaceObject dso, String identifier)
throws IdentifierException, IllegalArgumentException, SQLException {
registerOnline(context, dso, identifier, this.filter);
}
/**
* Perform the actual online / API interaction required to register the DOI online
* @param context - DSpace context
* @param dso - DSpaceObject identified by this DOI
* @param identifier - String containing the DOI to register
* @param filter - Logical item filter to determine whether this identifier should be registered online
* @throws IdentifierException
* @throws IllegalArgumentException
* @throws SQLException
*/
public void registerOnline(Context context, DSpaceObject dso, String identifier, Filter filter)
throws IdentifierException, IllegalArgumentException, SQLException {
String doi = doiService.formatIdentifier(identifier);
// get TableRow and ensure DOI belongs to dso regarding our db
DOI doiRow = loadOrCreateDOI(context, dso, doi, filter);
if (DELETED.equals(doiRow.getStatus()) || TO_BE_DELETED.equals(doiRow.getStatus())) {
throw new DOIIdentifierException("You tried to register a DOI that "
+ "is marked as DELETED.", DOIIdentifierException.DOI_IS_DELETED);
}
// register DOI Online
try {
connector.registerDOI(context, dso, doi);
} catch (DOIIdentifierException die) {
// do we have to reserve DOI before we can register it?
if (die.getCode() == DOIIdentifierException.RESERVE_FIRST) {
this.reserveOnline(context, dso, identifier, filter);
connector.registerDOI(context, dso, doi);
} else {
throw die;
}
}
// safe DOI as metadata of the item
try {
saveDOIToObject(context, dso, doi);
} catch (AuthorizeException ae) {
throw new IdentifierException("Not authorized to save a DOI as metadata of an dso!", ae);
} catch (SQLException sqle) {
throw new RuntimeException(sqle);
}
doiRow.setStatus(IS_REGISTERED);
doiService.update(context, doiRow);
}
/**
* Update metadata for a registered object
* If the DOI for the item already exists, *always* skip the filter since it should only be used for
* allowing / disallowing reservation and registration, not metadata updates or deletions
*
* @param context - DSpace context
* @param dso - DSpaceObject identified by this DOI
* @param identifier - String containing the DOI to reserve
* @throws IdentifierException
* @throws IllegalArgumentException
* @throws SQLException
*/
public void updateMetadata(Context context, DSpaceObject dso, String identifier)
throws IdentifierException, IllegalArgumentException, SQLException {
String doi = doiService.formatIdentifier(identifier);
// Use the default filter unless we find the object
Filter updateFilter = this.filter;
if (doiService.findDOIByDSpaceObject(context, dso) != null) {
// We can skip the filter here since we know the DOI already exists for the item
log.debug("updateMetadata: found DOIByDSpaceObject: {}",
doiService.findDOIByDSpaceObject(context, dso).getDoi());
updateFilter = DSpaceServicesFactory.getInstance().getServiceManager().getServiceByName(
"always_true_filter", TrueFilter.class);
}
DOI doiRow = loadOrCreateDOI(context, dso, doi, updateFilter);
if (PENDING.equals(doiRow.getStatus()) || MINTED.equals(doiRow.getStatus())) {
log.info("Not updating metadata for PENDING or MINTED doi: {}", doi);
return;
}
if (DELETED.equals(doiRow.getStatus()) || TO_BE_DELETED.equals(doiRow.getStatus())) {
throw new DOIIdentifierException("You tried to register a DOI that "
+ "is marked as DELETED.", DOIIdentifierException.DOI_IS_DELETED);
}
if (IS_REGISTERED.equals(doiRow.getStatus())) {
doiRow.setStatus(UPDATE_REGISTERED);
} else if (TO_BE_REGISTERED.equals(doiRow.getStatus())) {
doiRow.setStatus(UPDATE_BEFORE_REGISTRATION);
} else if (IS_RESERVED.equals(doiRow.getStatus())) {
doiRow.setStatus(UPDATE_RESERVED);
} else {
return;
}
doiService.update(context, doiRow);
}
/**
* Update metadata for a registered object in the DOI Connector to update the agency records
* If the DOI for the item already exists, *always* skip the filter since it should only be used for
* allowing / disallowing reservation and registration, not metadata updates or deletions
*
* @param context - DSpace context
* @param dso - DSpaceObject identified by this DOI
* @param identifier - String containing the DOI to reserve
* @throws IdentifierException
* @throws IllegalArgumentException
* @throws SQLException
*/
public void updateMetadataOnline(Context context, DSpaceObject dso, String identifier)
throws IdentifierException, SQLException {
String doi = doiService.formatIdentifier(identifier);
// ensure DOI belongs to dso regarding our db
DOI doiRow = null;
try {
doiRow = doiService.findByDoi(context, doi.substring(DOI.SCHEME.length()));
} catch (SQLException sqle) {
log.warn("SQLException while searching a DOI in our db.", sqle);
throw new RuntimeException("Unable to retrieve information about a DOI out of database.", sqle);
}
if (null == doiRow) {
log.error("Cannot update metadata for DOI {}: unable to find it in our db.", doi);
throw new DOIIdentifierException("Unable to find DOI.",
DOIIdentifierException.DOI_DOES_NOT_EXIST);
}
if (!Objects.equals(doiRow.getDSpaceObject(), dso)) {
log.error("Refuse to update metadata of DOI {} with the metadata of "
+ " an object ({}/{}) the DOI is not dedicated to.",
doi,
contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso),
dso.getID().toString());
throw new DOIIdentifierException("Cannot update DOI metadata: "
+ "DOI and DSpaceObject does not match!",
DOIIdentifierException.MISMATCH);
}
if (DELETED.equals(doiRow.getStatus()) || TO_BE_DELETED.equals(doiRow.getStatus())) {
throw new DOIIdentifierException("You tried to update the metadata"
+ " of a DOI that is marked as DELETED.",
DOIIdentifierException.DOI_IS_DELETED);
}
connector.updateMetadata(context, dso, doi);
if (UPDATE_REGISTERED.equals(doiRow.getStatus())) {
doiRow.setStatus(IS_REGISTERED);
} else if (UPDATE_BEFORE_REGISTRATION.equals(doiRow.getStatus())) {
doiRow.setStatus(TO_BE_REGISTERED);
} else if (UPDATE_RESERVED.equals(doiRow.getStatus())) {
doiRow.setStatus(IS_RESERVED);
}
doiService.update(context, doiRow);
}
/**
* Mint a new DOI in DSpace - this is usually the first step of registration
* Always apply filters if they are configured
* @param context - DSpace context
* @param dso - DSpaceObject identified by the new identifier
* @return a String containing the new identifier
* @throws IdentifierException
*/
@Override
public String mint(Context context, DSpaceObject dso)
throws IdentifierException {
return mint(context, dso, this.filter);
}
/**
* Mint a new DOI in DSpace - this is usually the first step of registration
* @param context - DSpace context
* @param dso - DSpaceObject identified by the new identifier
* @param filter - Logical item filter to determine whether this identifier should be registered
* @return a String containing the new identifier
* @throws IdentifierException
*/
@Override
public String mint(Context context, DSpaceObject dso, Filter filter) throws IdentifierException {
String doi = null;
try {
doi = getDOIByObject(context, dso);
} catch (SQLException e) {
log.error("Error while attempting to retrieve information about a DOI for {} with ID {}.",
contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso), dso.getID());
throw new RuntimeException("Error while attempting to retrieve " +
"information about a DOI for " + contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso) +
" with ID " + dso.getID() + ".", e);
}
if (null == doi) {
try {
DOI doiRow = loadOrCreateDOI(context, dso, null, filter);
doi = DOI.SCHEME + doiRow.getDoi();
} catch (SQLException e) {
log.error("Error while creating new DOI for Object of " +
"ResourceType {} with id {}.", dso::getType, dso::getID);
throw new RuntimeException("Error while attempting to create a " +
"new DOI for " + contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso) + " with ID " +
dso.getID() + ".", e);
}
}
return doi;
}
/**
* Resolve an identifier to a DSpaceObject, if it is registered
* @param context - DSpace context
* @param identifier - to be resolved.
* @param attributes - additional information for resolving {@code identifier}.
* @return a DSpaceObject identified by the identifier string
* @throws IdentifierNotFoundException
* @throws IdentifierNotResolvableException
*/
@Override
public DSpaceObject resolve(Context context, String identifier, String... attributes)
throws IdentifierNotFoundException, IdentifierNotResolvableException {
String doi = null;
try {
doi = doiService.formatIdentifier(identifier);
} catch (IdentifierException e) {
throw new IdentifierNotResolvableException(e);
}
try {
DSpaceObject dso = getObjectByDOI(context, doi);
if (null == dso) {
throw new IdentifierNotFoundException();
}
return dso;
} catch (SQLException sqle) {
log.error("SQLException while searching a DOI in our db.", sqle);
throw new RuntimeException("Unable to retrieve information about a DOI out of database.", sqle);
} catch (IdentifierException e) {
throw new IdentifierNotResolvableException(e);
}
}
/**
* Look up a DOI identifier for a given DSpaceObject
* @param context - DSpace context
* @param dso - DSpaceObject to look up
* @return a String containing the DOI
* @throws IdentifierNotFoundException
* @throws IdentifierNotResolvableException
*/
@Override
public String lookup(Context context, DSpaceObject dso)
throws IdentifierNotFoundException, IdentifierNotResolvableException {
String doi = null;
try {
doi = getDOIByObject(context, dso);
} catch (SQLException e) {
throw new RuntimeException("Error retrieving DOI out of database.", e);
}
if (null == doi) {
throw new IdentifierNotFoundException("No DOI for DSpaceObject of type " +
contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso) +
" with ID " + dso.getID() + " found.");
}
return doi;
}
/**
* Delete all DOIs for a DSpaceObject
* @param context - DSpace context
* @param dso - DSpaceObject to have all its DOIs deleted
* @throws IdentifierException
*/
@Override
public void delete(Context context, DSpaceObject dso)
throws IdentifierException {
// delete all DOIs for this Item from our database.
try {
String doi = getDOIByObject(context, dso);
while (null != doi) {
this.delete(context, dso, doi);
doi = getDOIByObject(context, dso);
}
} catch (SQLException ex) {
log.error("Error while attempting to retrieve information about a DOI for {} with ID {}.",
contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso),
dso.getID(), ex);
throw new RuntimeException("Error while attempting to retrieve " +
"information about a DOI for " + contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso) +
" with ID " + dso.getID() + ".", ex);
}
// delete all DOIs of this item out of its metadata
try {
String doi = getDOIOutOfObject(dso);
while (null != doi) {
this.removeDOIFromObject(context, dso, doi);
doi = getDOIOutOfObject(dso);
}
} catch (AuthorizeException ex) {
log.error("Error while removing a DOI out of the metadata of an {} with ID {}.",
contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso),
dso.getID(), ex);
throw new RuntimeException("Error while removing a DOI out of the metadata of an " +
contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso) +
" with ID " + dso.getID() + ".", ex);
} catch (SQLException ex) {
log.error("Error while removing a DOI out of the metadata of an {} with ID {}.",
contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso),
dso.getID(), ex);
throw new RuntimeException("Error while removing a DOI out of the " +
"metadata of an " + contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso) +
" with ID " + dso.getID() + ".", ex);
}
}
/**
* Delete a specific DOI for a given DSpaceObject
* @param context - DSpace context
* @param dso - DSpaceObject to be de-identified.
* @param identifier - String containing identifier to delete
* @throws IdentifierException
*/
@Override
public void delete(Context context, DSpaceObject dso, String identifier)
throws IdentifierException {
String doi = doiService.formatIdentifier(identifier);
DOI doiRow = null;
try {
doiRow = doiService.findByDoi(context, doi.substring(DOI.SCHEME.length()));
} catch (SQLException sqle) {
throw new RuntimeException(sqle);
}
// check if DOI belongs to dso
if (null != doiRow) {
if (!Objects.equals(dso, doiRow.getDSpaceObject())) {
throw new DOIIdentifierException("Trying to delete a DOI out of "
+ "an object that is not addressed by the DOI.",
DOIIdentifierException.MISMATCH);
}
}
// remove DOI from metadata
try {
removeDOIFromObject(context, dso, doi);
} catch (AuthorizeException ex) {
log.error("Not authorized to delete a DOI out of an Item.", ex);
throw new DOIIdentifierException("Not authorized to delete DOI.",
ex, DOIIdentifierException.UNAUTHORIZED_METADATA_MANIPULATION);
} catch (SQLException ex) {
log.error("SQLException occurred while deleting a DOI out of an item: {}",
ex::getMessage);
throw new RuntimeException("Error while deleting a DOI out of the " +
"metadata of an Item " + dso.getID(), ex);
}
// change doi status in db if necessary.
if (null != doiRow) {
doiRow.setDSpaceObject(null);
if (doiRow.getStatus() == null) {
doiRow.setStatus(DELETED);
} else {
doiRow.setStatus(TO_BE_DELETED);
}
try {
doiService.update(context, doiRow);
} catch (SQLException sqle) {
log.warn("SQLException while changing status of DOI {} to be deleted.", doi);
throw new RuntimeException(sqle);
}
}
// DOI is a permanent identifier. DataCite for example does not delete
// DOIS. But it is possible to mark a DOI as "inactive".
}
/**
* Delete a specific DOI in the registration agency records via the DOI Connector
* @param context - DSpace context
* @param identifier - String containing identifier to delete
* @throws DOIIdentifierException
*/
public void deleteOnline(Context context, String identifier) throws DOIIdentifierException {
String doi = doiService.formatIdentifier(identifier);
DOI doiRow = null;
try {
doiRow = doiService.findByDoi(context, doi.substring(DOI.SCHEME.length()));
} catch (SQLException sqle) {
throw new RuntimeException(sqle);
}
if (null == doiRow) {
throw new DOIIdentifierException("This identifier: " + identifier
+ " isn't in our database",
DOIIdentifierException.DOI_DOES_NOT_EXIST);
}
if (!TO_BE_DELETED.equals(doiRow.getStatus())) {
log.error("This identifier: " + DOI.SCHEME
+ "{} couldn't be deleted. Delete it first from metadata.",
doiRow::getDoi);
throw new IllegalArgumentException("Couldn't delete this identifier:"
+ DOI.SCHEME + doiRow.getDoi()
+ ". Delete it first from metadata.");
}
connector.deleteDOI(context, doi);
doiRow.setStatus(DELETED);
try {
doiService.update(context, doiRow);
} catch (SQLException sqle) {
log.warn("SQLException while changing status of DOI {} deleted.", doi);
throw new RuntimeException(sqle);
}
}
/**
* Returns a DSpaceObject depending on its DOI.
* @param context the context
* @param identifier The DOI in a format that is accepted by
* {@link org.dspace.identifier.service.DOIService#formatIdentifier(String)}.
* @return Null if the DOI couldn't be found or the associated DSpaceObject.
* @throws SQLException if database error
* @throws DOIIdentifierException If {@code identifier} is null or an empty string.
* @throws IllegalArgumentException If the identifier couldn't be recognized as DOI.
*/
public DSpaceObject getObjectByDOI(Context context, String identifier)
throws SQLException, DOIIdentifierException, IllegalArgumentException {
String doi = doiService.formatIdentifier(identifier);
DOI doiRow = doiService.findByDoi(context, doi.substring(DOI.SCHEME.length()));
if (null == doiRow) {
return null;
}
if (doiRow.getDSpaceObject() == null) {
log.error("Found DOI {} in database, but no assigned Object could be found.", doi);
throw new IllegalStateException("Found DOI " + doi +
" in database, but no assigned Object could be found.");
}
return doiRow.getDSpaceObject();
}
/**
* Search the database for a DOI, using the type and id of an DSpaceObject.
*
* @param context The relevant DSpace Context.
* @param dso DSpaceObject to find doi for. DOIs with status TO_BE_DELETED will be
* ignored.
* @return The DOI as String or null if DOI was not found.
* @throws SQLException if database error
*/
public String getDOIByObject(Context context, DSpaceObject dso) throws SQLException {
// String sql = "SELECT * FROM Doi WHERE resource_type_id = ? " +
// "AND resource_id = ? AND ((status != ? AND status != ?) OR status IS NULL)";
DOI doiRow = doiService.findDOIByDSpaceObject(context, dso, Arrays.asList(DELETED, TO_BE_DELETED));
if (null == doiRow) {
return null;
}
if (doiRow.getDoi() == null) {
log.error("A DOI with an empty doi column was found in the database. DSO-Type: {}, ID: {}.",
contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso),
dso.getID());
throw new IllegalStateException("A DOI with an empty doi column was found in the database. DSO-Type: " +
contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso) + ", ID: " + dso.getID() + ".");
}
return DOI.SCHEME + doiRow.getDoi();
}
/**
* Load a DOI from the database or creates it if it does not exist.
* This method can be used to ensure that a DOI exists in the database and
* to load the appropriate TableRow. As protected method we don't check if
* the DOI is in a decent format, use DOI.formatIdentifier(String) if necessary.
*
* @param context The relevant DSpace Context.
* @param dso The DSpaceObject the DOI should be loaded or created for.
* @param doiIdentifier A DOI or null if a DOI should be generated. The generated DOI
* can be found in the appropriate column for the TableRow.
* @return The database row of the object.
* @throws SQLException In case of an error using the database.
* @throws DOIIdentifierException If {@code doi} is not part of our prefix or
* DOI is registered for another object already.
* @throws IdentifierNotApplicableException passed through.
*/
protected DOI loadOrCreateDOI(Context context, DSpaceObject dso, String doiIdentifier)
throws SQLException, DOIIdentifierException, IdentifierNotApplicableException {
return loadOrCreateDOI(context, dso, doiIdentifier, this.filter);
}
/**
* Load DOI from database, or create one if it doesn't yet exist.
* We need to distinguish several cases.LoadOrCreate can be called with a
* specified identifier to load or create. It can also be used to create a
* new unspecified identifier. In the latter case doiIdentifier is set null.
* If doiIdentifier is set, we know which doi we should try to load or
* create, but even in such a situation we might be able to find it in the
* database or might have to create it.
*
* @param context - DSpace context
* @param dso - DSpaceObject to identify
* @param doiIdentifier - DOI to load or create (null to mint a new one)
* @param filter - Logical item filter to determine whether this identifier should be registered
* @return
* @throws SQLException
* @throws DOIIdentifierException
* @throws org.dspace.identifier.IdentifierNotApplicableException passed through.
*/
protected DOI loadOrCreateDOI(Context context, DSpaceObject dso, String doiIdentifier, Filter filter)
throws SQLException, DOIIdentifierException, IdentifierNotApplicableException {
DOI doi = null;
// Was an identifier specified that we shall try to load or create if it is not existing yet?
if (null != doiIdentifier) {
// we expect DOIs to have the DOI-Scheme except inside the doi table:
doiIdentifier = doiIdentifier.substring(DOI.SCHEME.length());
// check if DOI is already in Database
doi = doiService.findByDoi(context, doiIdentifier);
if (null != doi) {
if (doi.getDSpaceObject() == null) {
// doi was deleted, check resource type
if (doi.getResourceTypeId() != null
&& doi.getResourceTypeId() != dso.getType()) {
// doi was assigned to another resource type. Don't
// reactivate it
throw new DOIIdentifierException("Cannot reassign"
+ " previously deleted DOI " + doiIdentifier
+ " as the resource types of the object it was"
+ " previously assigned to and the object it"
+ " shall be assigned to now differ (was: "
+ Constants.typeText[doi.getResourceTypeId()]
+ ", trying to assign to "
+ Constants.typeText[dso.getType()] + ").",
DOIIdentifierException.DOI_IS_DELETED);
} else {
// reassign doi
// nothing to do here, doi will br reassigned after this
// if-else-if-else-...-block
// will check if a filter prohibits creation of DOIs after this if-else-block
}
} else {
// doi is assigned to a DSO; is it assigned to our specific dso?
// check if DOI already belongs to dso
if (dso.getID().equals(doi.getDSpaceObject().getID())) {
// Before we return this, check the filter
checkMintable(context, filter, dso);
return doi;
} else {
throw new DOIIdentifierException("Trying to create a DOI " +
"that is already reserved for another object.",
DOIIdentifierException.DOI_ALREADY_EXISTS);
}
}
}
// Check if this item is eligible for minting. An IdentifierNotApplicableException will be thrown if not.
checkMintable(context, filter, dso);
// check prefix
if (!doiIdentifier.startsWith(this.getPrefix() + "/")) {
throw new DOIIdentifierException("Trying to create a DOI " +
"that's not part of our Namespace!",
DOIIdentifierException.FOREIGN_DOI);
}
if (doi == null) {
// prepare new doiRow
doi = doiService.create(context);
}
} else {
// Check if this item is eligible for minting. An IdentifierNotApplicableException will be thrown if not.
checkMintable(context, filter, dso);
doi = doiService.create(context);
doiIdentifier = this.getPrefix() + "/" + this.getNamespaceSeparator() +
doi.getID();
}
// prepare new doiRow
doi.setDoi(doiIdentifier);
doi.setDSpaceObject(dso);
doi.setStatus(MINTED);
try {
doiService.update(context, doi);
} catch (SQLException e) {
throw new RuntimeException("Cannot save DOI to database for unknown reason.");
}
return doi;
}
/**
* Loads a DOI out of the metadata of an DSpaceObject.
*
* @param dso DSpace object to get DOI metadata from
* @return The DOI or null if no DOI was found.
* @throws DOIIdentifierException if identifier error
*/
public String getDOIOutOfObject(DSpaceObject dso) throws DOIIdentifierException {
// FIXME
if (!(dso instanceof Item)) {
throw new IllegalArgumentException("We currently support DOIs for Items only, not for " +
contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso) + ".");
}
Item item = (Item) dso;
List metadata = itemService.getMetadata(item, MD_SCHEMA, DOI_ELEMENT, DOI_QUALIFIER, null);
String leftPart = doiService.getResolver() + SLASH + getPrefix() + SLASH + getNamespaceSeparator();
for (MetadataValue id : metadata) {
if (id.getValue().startsWith(leftPart)) {
return doiService.DOIFromExternalFormat(id.getValue());
}
}
return null;
}
/**
* Adds a DOI to the metadata of an item.
*
* @param context The relevant DSpace Context.
* @param dso DSpaceObject the DOI should be added to.
* @param doi The DOI that should be added as metadata.
* @throws SQLException if database error
* @throws AuthorizeException if authorization error
* @throws IdentifierException if identifier error
*/
protected void saveDOIToObject(Context context, DSpaceObject dso, String doi)
throws SQLException, AuthorizeException, IdentifierException {
// FIXME
if (!(dso instanceof Item)) {
throw new IllegalArgumentException("We currently support DOIs for Items only, not for " +
contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso) + ".");
}
Item item = (Item) dso;
itemService.addMetadata(context, item, MD_SCHEMA, DOI_ELEMENT, DOI_QUALIFIER, null,
doiService.DOIToExternalForm(doi));
try {
itemService.update(context, item);
} catch (SQLException | AuthorizeException ex) {
throw ex;
}
}
/**
* Removes a DOI out of the metadata of a DSpaceObject.
*
* @param context The relevant DSpace Context.
* @param dso The DSpaceObject the DOI should be removed from.
* @param doi The DOI to remove out of the metadata.
* @throws AuthorizeException if authorization error
* @throws SQLException if database error
* @throws IdentifierException if identifier error
*/
protected void removeDOIFromObject(Context context, DSpaceObject dso, String doi)
throws AuthorizeException, SQLException, IdentifierException {
// FIXME
if (!(dso instanceof Item)) {
throw new IllegalArgumentException("We currently support DOIs for Items only, not for " +
contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso) + ".");
}
Item item = (Item) dso;
List metadata = itemService.getMetadata(item, MD_SCHEMA, DOI_ELEMENT, DOI_QUALIFIER, null);
List remainder = new ArrayList<>();
for (MetadataValue id : metadata) {
if (!id.getValue().equals(doiService.DOIToExternalForm(doi))) {
remainder.add(id.getValue());
}
}
itemService.clearMetadata(context, item, MD_SCHEMA, DOI_ELEMENT, DOI_QUALIFIER, null);
itemService.addMetadata(context, item, MD_SCHEMA, DOI_ELEMENT, DOI_QUALIFIER, null,
remainder);
itemService.update(context, item);
}
/**
* Checks to see if an item can have a DOI minted, using the configured logical filter
* @param context
* @param filter Logical item filter to apply
* @param dso The item to be evaluated
* @throws DOIIdentifierNotApplicableException
*/
@Override
public void checkMintable(Context context, Filter filter, DSpaceObject dso)
throws DOIIdentifierNotApplicableException {
if (filter == null) {
Filter trueFilter = DSpaceServicesFactory.getInstance().getServiceManager().getServiceByName(
"always_true_filter", TrueFilter.class);
// If a null filter was passed, and we have a good default filter to apply, apply it.
// Otherwise, set to TrueFilter which means "no filtering"
if (this.filter != null) {
filter = this.filter;
} else {
filter = trueFilter;
}
}
// If the check fails, an exception will be thrown to be caught by the calling method
if (contentServiceFactory.getDSpaceObjectService(dso).getTypeText(dso).equals("ITEM")) {
try {
boolean result = filter.getResult(context, (Item) dso);
log.debug("Result of filter for {} is {}", dso.getHandle(), result);
if (!result) {
throw new DOIIdentifierNotApplicableException("Item " + dso.getHandle() +
" was evaluated as 'false' by the item filter, not minting");
}
} catch (LogicalStatementException e) {
log.error("Error evaluating item with logical filter: {}", e::getLocalizedMessage);
throw new DOIIdentifierNotApplicableException(e);
}
} else {
log.debug("DOI Identifier Provider: filterService is null (ie. don't prevent DOI minting)");
}
}
/**
* Checks to see if an item can have a DOI minted, using the configured logical filter
* @param context
* @param dso The item to be evaluated
* @throws DOIIdentifierNotApplicableException
*/
@Override
public void checkMintable(Context context, DSpaceObject dso) throws DOIIdentifierNotApplicableException {
checkMintable(context, this.filter, dso);
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy