org.dspace.content.authority.MetadataAuthorityManager Maven / Gradle / Ivy

Go to download
/**
 * 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.content.authority;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.Enumeration;


import org.apache.log4j.Logger;

import org.dspace.content.MetadataField;
import org.dspace.core.ConfigurationManager;

/**
 * Broker for metadata authority settings configured for each metadata field.
 *
 * Configuration keys, per metadata field (e.g. "dc.contributer.author")
 *
 *  # is field authority controlled (i.e. store authority, confidence values)?
 *  authority.controlled. = true
 *
 *  # is field required to have an authority value, or may it be empty?
 *  # default is false.
 *  authority.required. = true | false
 *
 *  # default value of minimum confidence level for ALL fields - must be
 *  # symbolic confidence level, see org.dspace.content.authority.Choices
 *  authority.minconfidence = uncertain
 *
 *  # minimum confidence level for this field
 *  authority.minconfidence.SCHEMA.ELEMENT.QUALIFIER = SYMBOL
 *    e.g.
 *  authority.minconfidence.dc.contributor.author = accepted
 *
 * NOTE: There is *expected* to be a "choices" (see ChoiceAuthorityManager)
 * configuration for each authority-controlled field.
 *
 * @see ChoiceAuthorityManager
 * @see Choices
 * @author Larry Stone
 */
public class MetadataAuthorityManager
{
    private static Logger log = Logger.getLogger(MetadataAuthorityManager.class);

    private static MetadataAuthorityManager cached = null;

    // map of field key to authority plugin
    private Map controlled = new HashMap();

    // map of field key to answer of whether field is required to be controlled
    private Map isAuthorityRequired = new HashMap();

    /**
     * map of field key to answer of which is the min acceptable confidence
     * value for a field with authority
     */
    private Map minConfidence = new HashMap();

    /** fallback default value unless authority.minconfidence = X is configured. */
    private int defaultMinConfidence = Choices.CF_ACCEPTED;

    private MetadataAuthorityManager()
    {

        Enumeration pn = ConfigurationManager.propertyNames();
        final String authPrefix = "authority.controlled.";
      property:
        while (pn.hasMoreElements())
        {
            String key = (String)pn.nextElement();
            if (key.startsWith(authPrefix))
            {
                // field is expected to be "schema.element.qualifier"
                String field = key.substring(authPrefix.length());
                int dot = field.indexOf('.');
                if (dot < 0)
                {
                    log.warn("Skipping invalid MetadataAuthority configuration property: "+key+": does not have schema.element.qualifier");
                    continue property;
                }
                String schema = field.substring(0, dot);
                String element = field.substring(dot+1);
                String qualifier = null;
                dot = element.indexOf('.');
                if (dot >= 0)
                {
                    qualifier = element.substring(dot+1);
                    element = element.substring(0, dot);
                }

                String fkey = makeFieldKey(schema, element, qualifier);
                boolean ctl = ConfigurationManager.getBooleanProperty(key, true);
                boolean req = ConfigurationManager.getBooleanProperty("authority.required."+field, false);
                controlled.put(fkey, Boolean.valueOf(ctl));
                isAuthorityRequired.put(fkey, Boolean.valueOf(req));

                // get minConfidence level for this field if any
                int mci = readConfidence("authority.minconfidence."+field);
                if (mci >= Choices.CF_UNSET)
                {
                    minConfidence.put(fkey, Integer.valueOf(mci));
                }
                log.debug("Authority Control: For schema="+schema+", elt="+element+", qual="+qualifier+", controlled="+ctl+", required="+req);
            }
        }

        // get default min confidence if any:
        int dmc = readConfidence("authority.minconfidence");
        if (dmc >= Choices.CF_UNSET)
        {
            defaultMinConfidence = dmc;
        }
    }

    private int readConfidence(String key)
    {
        String mc = ConfigurationManager.getProperty(key);
        if (mc != null)
        {
            int mci = Choices.getConfidenceValue(mc.trim(), Choices.CF_UNSET-1);
            if (mci == Choices.CF_UNSET-1)
                {
                log.warn("IGNORING bad value in DSpace Configuration, key="+key+", value="+mc+", must be a valid Authority Confidence keyword.");
                }
            else
            {
                return mci;
            }
        }
        return Choices.CF_UNSET-1;
    }

    // factory method
    public static MetadataAuthorityManager getManager()
    {
        if (cached == null)
        {
            cached = new MetadataAuthorityManager();
        }
        return cached;
    }


    /** Predicate - is field authority-controlled? */
    public boolean isAuthorityControlled(String schema, String element, String qualifier)
    {
        return isAuthorityControlled(makeFieldKey(schema, element, qualifier));
    }

    /** Predicate - is field authority-controlled? */
    public boolean isAuthorityControlled(String fieldKey)
    {
        return controlled.containsKey(fieldKey) && controlled.get(fieldKey).booleanValue();
    }


    /** Predicate - is authority value required for field? */
    public boolean isAuthorityRequired(String schema, String element, String qualifier)
    {
        return isAuthorityRequired(makeFieldKey(schema, element, qualifier));
    }

    /** Predicate - is authority value required for field? */
    public boolean isAuthorityRequired(String fieldKey)
    {
        Boolean result = isAuthorityRequired.get(fieldKey);
        return (result == null) ? false : result.booleanValue();
    }

    /**
     * Construct a single key from the tuple of schema/element/qualifier
     * that describes a metadata field.  Punt to the function we use for
     * submission UI input forms, for now.
     */
    public static String makeFieldKey(String schema, String element, String qualifier)
    {
        return MetadataField.formKey(schema, element, qualifier);
    }

    /**
     * Give the minimal level of confidence required to consider valid an authority value
     * for the given metadata.
     * @return the minimal valid level of confidence for the given metadata
     */
    public int getMinConfidence(String schema, String element, String qualifier)
    {
        Integer result = minConfidence.get(makeFieldKey(schema, element, qualifier));
        return result == null ? defaultMinConfidence : result.intValue();
    }

    /**
     * Return the list of metadata field with authority control. The strings
     * are in the form schema.element[.qualifier]
     *
     * @return the list of metadata field with authority control
     */
    public List getAuthorityMetadata() {
        List copy = new ArrayList();
        for (String s : controlled.keySet())
        {
            copy.add(s.replaceAll("_","."));
        }
        return copy;
    }
}