/**
* 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.sql.SQLException;
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.content.authority.service.MetadataAuthorityService;
import org.dspace.content.service.MetadataFieldService;
import org.dspace.core.ConfigurationManager;
import org.dspace.core.Context;
import org.springframework.beans.factory.annotation.Autowired;
/**
* Broker for metadata authority settings configured for each metadata field.
*
* Configuration keys, per metadata field (e.g. "dc.contributer.author")
*
* {@code
* # is field authority controlled (i.e. store authority, confidence values)?
* authority.controlled.<FIELD> = true
*
* # is field required to have an authority value, or may it be empty?
* # default is false.
* authority.required.<FIELD> = 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 ChoiceAuthorityServiceImpl
* @see Choices
* @author Larry Stone
*/
public class MetadataAuthorityServiceImpl implements MetadataAuthorityService
{
private static Logger log = Logger.getLogger(MetadataAuthorityServiceImpl.class);
@Autowired(required = true)
protected MetadataFieldService metadataFieldService;
// map of field key to authority plugin
protected Map<String,Boolean> controlled = new HashMap<String,Boolean>();
// map of field key to answer of whether field is required to be controlled
protected Map<String,Boolean> isAuthorityRequired = null;
/**
* map of field key to answer of which is the min acceptable confidence
* value for a field with authority
*/
protected Map<String, Integer> minConfidence = new HashMap<String, Integer>();
/** fallback default value unless authority.minconfidence = X is configured. */
protected int defaultMinConfidence = Choices.CF_ACCEPTED;
protected MetadataAuthorityServiceImpl()
{
}
public void init() {
if(isAuthorityRequired == null)
{
isAuthorityRequired = new HashMap<String,Boolean>();
Enumeration pn = ConfigurationManager.propertyNames();
final String authPrefix = "authority.controlled.";
Context context = new Context();
try {
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;
}
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);
}
MetadataField metadataField = metadataFieldService.findByElement(context, schema, element, qualifier);
if(metadataField == null)
{
throw new IllegalStateException("Error while configuring authority control, metadata field: " + field + " could not be found");
}
boolean ctl = ConfigurationManager.getBooleanProperty(key, true);
boolean req = ConfigurationManager.getBooleanProperty("authority.required."+field, false);
controlled.put(metadataField.toString(), ctl);
isAuthorityRequired.put(metadataField.toString(), req);
// get minConfidence level for this field if any
int mci = readConfidence("authority.minconfidence."+field);
if (mci >= Choices.CF_UNSET)
{
minConfidence.put(metadataField.toString(), mci);
}
log.debug("Authority Control: For schema="+schema+", elt="+element+", qual="+qualifier+", controlled="+ctl+", required="+req);
}
}
} catch (SQLException e) {
log.error("Error reading authority config", e);
}
// 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;
}
@Override
public boolean isAuthorityControlled(MetadataField metadataField)
{
init();
return isAuthorityControlled(makeFieldKey(metadataField));
}
@Override
public boolean isAuthorityControlled(String fieldKey)
{
init();
return controlled.containsKey(fieldKey) && controlled.get(fieldKey);
}
@Override
public boolean isAuthorityRequired(MetadataField metadataField)
{
init();
return isAuthorityRequired(makeFieldKey(metadataField));
}
@Override
public boolean isAuthorityRequired(String fieldKey)
{
init();
Boolean result = isAuthorityRequired.get(fieldKey);
return (result != null) && result;
}
@Override
public String makeFieldKey(MetadataField metadataField)
{
init();
return metadataField.toString();
}
@Override
public String makeFieldKey(String schema, String element, String qualifier) {
init();
if (qualifier == null)
{
return schema + "_" + element;
}
else
{
return schema + "_" + element + "_" + qualifier;
}
}
/**
* Give the minimal level of confidence required to consider valid an authority value
* for the given metadata.
* @param metadataField metadata field
* @return the minimal valid level of confidence for the given metadata
*/
@Override
public int getMinConfidence(MetadataField metadataField)
{
init();
Integer result = minConfidence.get(makeFieldKey(metadataField));
return result == null ? defaultMinConfidence : result;
}
@Override
public List<String> getAuthorityMetadata() {
init();
List<String> copy = new ArrayList<>();
for (String s : controlled.keySet())
{
copy.add(s.replaceAll("_","."));
}
return copy;
}
}