DSpace/dspace-api/src/main/java/org/dspace/identifier/HandleIdentifierProvider.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.identifier;

import java.io.IOException;
import java.sql.SQLException;
import java.util.List;

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.MetadataSchemaEnum;
import org.dspace.content.MetadataValue;
import org.dspace.content.service.ItemService;
import org.dspace.core.ConfigurationManager;
import org.dspace.core.Context;
import org.dspace.core.LogManager;
import org.dspace.handle.service.HandleService;
import org.dspace.services.factory.DSpaceServicesFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * The old DSpace handle identifier service, used to create handles or retrieve objects based on their handle
 *
 * @author Fabio Bolognesi (fabio at atmire dot com)
 * @author Mark Diggory (markd at atmire dot com)
 * @author Ben Bosman (ben at atmire dot com)
 */
@Component
public class HandleIdentifierProvider extends IdentifierProvider {
    /**
     * log4j category
     */
    private static Logger log = org.apache.logging.log4j.LogManager.getLogger(HandleIdentifierProvider.class);

    /**
     * Prefix registered to no one
     */
    protected static final String EXAMPLE_PREFIX = "123456789";

    @Autowired(required = true)
    protected HandleService handleService;
    @Autowired(required = true)
    protected ItemService itemService;

    @Override
    public boolean supports(Class<? extends Identifier> identifier) {
        return Handle.class.isAssignableFrom(identifier);
    }

    @Override
    public boolean supports(String identifier) {
        String prefix = handleService.getPrefix();
        String canonicalPrefix = DSpaceServicesFactory.getInstance().getConfigurationService()
                                                      .getProperty("handle.canonical.prefix");
        if (identifier == null) {
            return false;
        }
        // return true if handle has valid starting pattern
        if (identifier.startsWith(prefix + "/")
            || identifier.startsWith(canonicalPrefix)
            || identifier.startsWith("hdl:")
            || identifier.startsWith("info:hdl")
            || identifier.matches("^https?://hdl\\.handle\\.net/.*")
            || identifier.matches("^https?://.+/handle/.*")) {
            return true;
        }

        //Check additional prefixes supported in the config file
        String[] additionalPrefixes = DSpaceServicesFactory.getInstance().getConfigurationService()
                                                           .getArrayProperty("handle.additional.prefixes");
        for (String additionalPrefix : additionalPrefixes) {
            if (identifier.startsWith(additionalPrefix + "/")) {
                return true;
            }
        }

        return false;
    }

    @Override
    public String register(Context context, DSpaceObject dso) {
        try {
            String id = mint(context, dso);

            // move canonical to point the latest version
            if (dso instanceof Item) {
                Item item = (Item) dso;
                populateHandleMetadata(context, item, id);
            }

            return id;
        } catch (Exception e) {
            log.error(
                LogManager.getHeader(context, "Error while attempting to create handle", "Item id: " + dso.getID()), e);
            throw new RuntimeException("Error while attempting to create identifier for Item id: " + dso.getID(), e);
        }
    }

    @Override
    public void register(Context context, DSpaceObject dso, String identifier) {
        try {
            handleService.createHandle(context, dso, identifier);
            if (dso instanceof Item) {
                Item item = (Item) dso;
                populateHandleMetadata(context, item, identifier);
            }
        } catch (Exception e) {
            log.error(
                LogManager.getHeader(context, "Error while attempting to create handle", "Item id: " + dso.getID()), e);
            throw new RuntimeException("Error while attempting to create identifier for Item id: " + dso.getID(), e);
        }
    }


    @Override
    public void reserve(Context context, DSpaceObject dso, String identifier) {
        try {
            handleService.createHandle(context, dso, identifier);
        } catch (Exception e) {
            log.error(
                LogManager.getHeader(context, "Error while attempting to create handle", "Item id: " + dso.getID()), e);
            throw new RuntimeException("Error while attempting to create identifier for Item id: " + dso.getID());
        }
    }


    /**
     * Creates a new handle in the database.
     *
     * @param context DSpace context
     * @param dso     The DSpaceObject to create a handle for
     * @return The newly created handle
     */
    @Override
    public String mint(Context context, DSpaceObject dso) {
        if (dso.getHandle() != null) {
            return dso.getHandle();
        }

        try {
            return handleService.createHandle(context, dso);
        } catch (Exception e) {
            log.error(
                LogManager.getHeader(context, "Error while attempting to create handle", "Item id: " + dso.getID()), e);
            throw new RuntimeException("Error while attempting to create identifier for Item id: " + dso.getID());
        }
    }

    @Override
    public DSpaceObject resolve(Context context, String identifier, String... attributes) {
        // We can do nothing with this, return null
        try {
            return handleService.resolveToObject(context, identifier);
        } catch (Exception e) {
            log.error(LogManager.getHeader(context, "Error while resolving handle to item", "handle: " + identifier),
                      e);
        }
//        throw new IllegalStateException("Unsupported Handle Type "
//                + Constants.typeText[handletypeid]);
        return null;
    }

    @Override
    public String lookup(Context context, DSpaceObject dso)
        throws IdentifierNotFoundException, IdentifierNotResolvableException {

        try {
            return handleService.findHandle(context, dso);
        } catch (SQLException sqe) {
            throw new IdentifierNotResolvableException(sqe.getMessage(), sqe);
        }
    }

    @Override
    public void delete(Context context, DSpaceObject dso, String identifier) throws IdentifierException {
        delete(context, dso);
    }

    @Override
    public void delete(Context context, DSpaceObject dso) throws IdentifierException {
        try {
            handleService.unbindHandle(context, dso);
        } catch (SQLException sqe) {
            throw new IdentifierException(sqe.getMessage(), sqe);
        }

    }

    public static String retrieveHandleOutOfUrl(String url)
        throws SQLException {
        // We can do nothing with this, return null
        if (!url.contains("/")) {
            return null;
        }

        String[] splitUrl = url.split("/");

        return splitUrl[splitUrl.length - 2] + "/" + splitUrl[splitUrl.length - 1];
    }

    /**
     * Get the configured Handle prefix string, or a default
     *
     * @return configured prefix or "123456789"
     */
    public static String getPrefix() {
        String prefix = ConfigurationManager.getProperty("handle.prefix");
        if (null == prefix) {
            prefix = EXAMPLE_PREFIX; // XXX no good way to exit cleanly
            log.error("handle.prefix is not configured; using " + prefix);
        }
        return prefix;
    }

    protected void populateHandleMetadata(Context context, Item item, String handle)
        throws SQLException, IOException, AuthorizeException {
        String handleref = handleService.getCanonicalForm(handle);

        // Add handle as identifier.uri DC value.
        // First check that identifier doesn't already exist.
        boolean identifierExists = false;
        List<MetadataValue> identifiers = itemService
            .getMetadata(item, MetadataSchemaEnum.DC.getName(), "identifier", "uri", Item.ANY);
        for (MetadataValue identifier : identifiers) {
            if (handleref.equals(identifier.getValue())) {
                identifierExists = true;
            }
        }
        if (!identifierExists) {
            itemService.addMetadata(context, item, MetadataSchemaEnum.DC.getName(),
                                    "identifier", "uri", null, handleref);
        }
    }
}