mirror of
https://github.com/DSpace/DSpace.git
synced 2025-10-14 21:43:11 +00:00
291 lines
16 KiB
Java
291 lines
16 KiB
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.content;
|
|
|
|
import java.sql.SQLException;
|
|
import java.util.HashMap;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import org.apache.commons.lang3.StringUtils;
|
|
import org.apache.logging.log4j.Logger;
|
|
import org.dspace.content.service.MetadataFieldService;
|
|
import org.dspace.content.service.RelationshipService;
|
|
import org.dspace.content.virtual.VirtualMetadataConfiguration;
|
|
import org.dspace.content.virtual.VirtualMetadataPopulator;
|
|
import org.dspace.core.Constants;
|
|
import org.dspace.core.Context;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
|
|
public class RelationshipMetadataServiceImpl implements RelationshipMetadataService {
|
|
|
|
/**
|
|
* log4j category
|
|
*/
|
|
private static final Logger log = org.apache.logging.log4j.LogManager.getLogger();
|
|
|
|
@Autowired(required = true)
|
|
protected RelationshipService relationshipService;
|
|
|
|
@Autowired(required = true)
|
|
protected VirtualMetadataPopulator virtualMetadataPopulator;
|
|
|
|
@Autowired(required = true)
|
|
protected MetadataFieldService metadataFieldService;
|
|
|
|
@Override
|
|
public List<RelationshipMetadataValue> getRelationshipMetadata(Item item, boolean enableVirtualMetadata) {
|
|
Context context = new Context();
|
|
List<RelationshipMetadataValue> fullMetadataValueList = new LinkedList<>();
|
|
try {
|
|
List<MetadataValue> list = item.getMetadata();
|
|
String entityType = getEntityTypeStringFromMetadata(list);
|
|
if (StringUtils.isNotBlank(entityType)) {
|
|
List<Relationship> relationships = relationshipService.findByItem(context, item);
|
|
for (Relationship relationship : relationships) {
|
|
fullMetadataValueList
|
|
.addAll(findRelationshipMetadataValueForItemRelationship(context, item, entityType,
|
|
relationship, enableVirtualMetadata));
|
|
}
|
|
|
|
}
|
|
} catch (SQLException e) {
|
|
log.error("Lookup for Relationships for item with uuid: " + item.getID() + " caused DSpace to crash", e);
|
|
}
|
|
return fullMetadataValueList;
|
|
}
|
|
|
|
private String getEntityTypeStringFromMetadata(List<MetadataValue> list) {
|
|
for (MetadataValue mdv : list) {
|
|
if (StringUtils.equals(mdv.getMetadataField().getMetadataSchema().getName(),
|
|
"relationship")
|
|
&& StringUtils.equals(mdv.getMetadataField().getElement(),
|
|
"type")) {
|
|
|
|
return mdv.getValue();
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* This method processes one Relationship of an Item and will return a list of RelationshipMetadataValue objects
|
|
* that are generated for this specific relationship for the item through the config in VirtualMetadataPopulator
|
|
*
|
|
* It returns a combination of the output of the findVirtualMetadataFromConfiguration method and
|
|
*
|
|
* @param context The context
|
|
* @param item The item whose virtual metadata is requested
|
|
* @param entityType The entity type of the given item
|
|
* @param relationship The relationship whose virtual metadata is requested
|
|
* @param enableVirtualMetadata Determines whether the VirtualMetadataPopulator should be used.
|
|
* If false, only the relation."relationname" metadata is populated
|
|
* If true, fields from the spring config virtual metadata is included as well
|
|
* @return The list of virtual metadata values
|
|
*/
|
|
private List<RelationshipMetadataValue> findRelationshipMetadataValueForItemRelationship(
|
|
Context context, Item item, String entityType, Relationship relationship, boolean enableVirtualMetadata)
|
|
throws SQLException {
|
|
List<RelationshipMetadataValue> resultingMetadataValueList = new LinkedList<>();
|
|
RelationshipType relationshipType = relationship.getRelationshipType();
|
|
HashMap<String, VirtualMetadataConfiguration> hashMaps;
|
|
String relationName;
|
|
Item otherItem;
|
|
int place = 0;
|
|
boolean isLeftwards;
|
|
if (StringUtils.equals(relationshipType.getLeftType().getLabel(), entityType)) {
|
|
hashMaps = virtualMetadataPopulator.getMap().get(relationshipType.getLeftwardType());
|
|
otherItem = relationship.getRightItem();
|
|
relationName = relationship.getRelationshipType().getLeftwardType();
|
|
place = relationship.getLeftPlace();
|
|
isLeftwards = false; //if the current item is stored on the left,
|
|
// the name variant is retrieved from the rightwards label
|
|
} else if (StringUtils.equals(relationshipType.getRightType().getLabel(), entityType)) {
|
|
hashMaps = virtualMetadataPopulator.getMap().get(relationshipType.getRightwardType());
|
|
otherItem = relationship.getLeftItem();
|
|
relationName = relationship.getRelationshipType().getRightwardType();
|
|
place = relationship.getRightPlace();
|
|
isLeftwards = true; //if the current item is stored on the right,
|
|
// the name variant is retrieved from the leftwards label
|
|
} else {
|
|
//No virtual metadata can be created
|
|
return resultingMetadataValueList;
|
|
}
|
|
|
|
if (hashMaps != null && enableVirtualMetadata) {
|
|
resultingMetadataValueList.addAll(findVirtualMetadataFromConfiguration(context, item, hashMaps,
|
|
otherItem, relationName,
|
|
relationship, place, isLeftwards));
|
|
}
|
|
RelationshipMetadataValue relationMetadataFromOtherItem =
|
|
getRelationMetadataFromOtherItem(context, otherItem, relationName, relationship.getID(), place);
|
|
if (relationMetadataFromOtherItem != null) {
|
|
resultingMetadataValueList.add(relationMetadataFromOtherItem);
|
|
}
|
|
return resultingMetadataValueList;
|
|
}
|
|
|
|
/**
|
|
* This method will retrieve a list of RelationshipMetadataValue objects based on the config passed along in the
|
|
* hashmaps parameter. The beans will be used to retrieve the values for the RelationshipMetadataValue objects
|
|
* and the keys of the hashmap will be used to construct the RelationshipMetadataValue object.
|
|
*
|
|
* @param context The context
|
|
* @param item The item whose virtual metadata is requested
|
|
* @param hashMaps The list of VirtualMetadataConfiguration objects which will generate the
|
|
* virtual metadata. These configurations are applicable for a relationship
|
|
* between both items
|
|
* @param otherItem The related item whose actual metadata is requested
|
|
* @param relationName The name of the relationship
|
|
* @param relationship The relationship whose virtual metadata is requested
|
|
* @param place The place to use in the virtual metadata
|
|
* @param isLeftwards Determines the direction of the virtual metadata
|
|
* @return The list of virtual metadata values
|
|
*/
|
|
private List<RelationshipMetadataValue> findVirtualMetadataFromConfiguration(Context context, Item item,
|
|
HashMap<String, VirtualMetadataConfiguration> hashMaps, Item otherItem, String relationName,
|
|
Relationship relationship, int place, boolean isLeftwards) throws SQLException {
|
|
|
|
List<RelationshipMetadataValue> resultingMetadataValueList = new LinkedList<>();
|
|
for (Map.Entry<String, VirtualMetadataConfiguration> entry : hashMaps.entrySet()) {
|
|
String key = entry.getKey();
|
|
VirtualMetadataConfiguration virtualBean = entry.getValue();
|
|
|
|
if (virtualBean.getPopulateWithNameVariant()) {
|
|
String wardLabel = isLeftwards ? relationship.getLeftwardValue() : relationship.getRightwardValue();
|
|
if (wardLabel != null) {
|
|
resultingMetadataValueList.add(
|
|
constructRelationshipMetadataValue(context, item, relationship.getID(), place, key, virtualBean,
|
|
wardLabel));
|
|
} else {
|
|
resultingMetadataValueList.addAll(
|
|
findRelationshipMetadataValueFromBean(context, item, otherItem, relationship, place, key,
|
|
virtualBean));
|
|
}
|
|
} else {
|
|
resultingMetadataValueList.addAll(
|
|
findRelationshipMetadataValueFromBean(context, item, otherItem, relationship, place, key,
|
|
virtualBean));
|
|
}
|
|
}
|
|
return resultingMetadataValueList;
|
|
}
|
|
|
|
/**
|
|
* This method will retrieve a list of RelationshipMetadataValue objects based on the config passed along in the
|
|
* hashmaps parameter. The beans will be used to retrieve the values for the RelationshipMetadataValue objects
|
|
* and the keys of the hashmap will be used to construct the RelationshipMetadataValue object.
|
|
*
|
|
* @param context The context
|
|
* @param item The item whose virtual metadata is requested
|
|
* @param otherItem The related item whose actual metadata is requested
|
|
* @param relationship The relationship whose virtual metadata is requested
|
|
* @param place The place to use in the virtual metadata
|
|
* @param key The key corresponding to the VirtualMetadataConfiguration
|
|
* @param virtualBean The VirtualMetadataConfiguration object which will generate the
|
|
* virtual metadata. This configuration is applicable for a relationship
|
|
* between both items
|
|
* @return The list of virtual metadata values
|
|
*/
|
|
private List<RelationshipMetadataValue> findRelationshipMetadataValueFromBean(
|
|
Context context, Item item, Item otherItem, Relationship relationship, int place,
|
|
String key, VirtualMetadataConfiguration virtualBean) throws SQLException {
|
|
List<RelationshipMetadataValue> resultingMetadataValueList = new LinkedList<>();
|
|
for (String value : virtualBean.getValues(context, otherItem)) {
|
|
RelationshipMetadataValue relationshipMetadataValue = constructRelationshipMetadataValue(context, item,
|
|
relationship
|
|
.getID(),
|
|
place,
|
|
key, virtualBean,
|
|
value);
|
|
if (relationshipMetadataValue != null) {
|
|
resultingMetadataValueList.add(relationshipMetadataValue);
|
|
}
|
|
}
|
|
return resultingMetadataValueList;
|
|
}
|
|
|
|
//This method will construct a RelationshipMetadataValue object with proper schema, element, qualifier,
|
|
//authority, item, place and useForPlace based on the key String parameter passed along to it
|
|
private RelationshipMetadataValue constructRelationshipMetadataValue(Context context, Item item,
|
|
Integer relationshipId, int place,
|
|
String key,
|
|
VirtualMetadataConfiguration virtualBean,
|
|
String value) {
|
|
RelationshipMetadataValue metadataValue = constructMetadataValue(context, key);
|
|
if (metadataValue != null) {
|
|
metadataValue = constructResultingMetadataValue(item, value, metadataValue, relationshipId);
|
|
metadataValue.setUseForPlace(virtualBean.getUseForPlace());
|
|
metadataValue.setPlace(place);
|
|
if (StringUtils.isNotBlank(metadataValue.getValue())) {
|
|
return metadataValue;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
//This method will construct a RelationshipMetadataValue object with proper schema, element and qualifier based
|
|
//on the key String parameter passed along to it
|
|
private RelationshipMetadataValue constructMetadataValue(Context context, String key) {
|
|
String[] splittedKey = key.split("\\.");
|
|
RelationshipMetadataValue metadataValue = new RelationshipMetadataValue();
|
|
String metadataSchema = splittedKey.length > 0 ? splittedKey[0] : null;
|
|
String metadataElement = splittedKey.length > 1 ? splittedKey[1] : null;
|
|
String metadataQualifier = splittedKey.length > 2 ? splittedKey[2] : null;
|
|
MetadataField metadataField = null;
|
|
try {
|
|
metadataField = metadataFieldService
|
|
.findByElement(context, metadataSchema, metadataElement, metadataQualifier);
|
|
} catch (SQLException e) {
|
|
log.error("Could not find element with MetadataSchema: " + metadataSchema +
|
|
", MetadataElement: " + metadataElement + " and MetadataQualifier: " + metadataQualifier, e);
|
|
return null;
|
|
}
|
|
if (metadataField == null) {
|
|
log.error("A MetadataValue was attempted to construct with MetadataField for parameters: " +
|
|
"metadataschema: {}, metadataelement: {}, metadataqualifier: {}",
|
|
metadataSchema, metadataElement, metadataQualifier);
|
|
return null;
|
|
}
|
|
metadataValue.setMetadataField(metadataField);
|
|
metadataValue.setLanguage(Item.ANY);
|
|
return metadataValue;
|
|
}
|
|
|
|
|
|
//This method will update a RelationshipMetadataValue object with authority info and relation to the item
|
|
private RelationshipMetadataValue constructResultingMetadataValue(Item item, String value,
|
|
RelationshipMetadataValue metadataValue,
|
|
Integer relationshipId) {
|
|
metadataValue.setValue(value);
|
|
metadataValue.setAuthority(Constants.VIRTUAL_AUTHORITY_PREFIX + relationshipId);
|
|
metadataValue.setConfidence(-1);
|
|
metadataValue.setDSpaceObject(item);
|
|
return metadataValue;
|
|
}
|
|
|
|
|
|
// This method will create the Relationship Metadatavalue that describes the relationship type and has the ID
|
|
// of the other item as value
|
|
private RelationshipMetadataValue getRelationMetadataFromOtherItem(Context context, Item otherItem,
|
|
String relationName,
|
|
Integer relationshipId, int place) {
|
|
RelationshipMetadataValue metadataValue = constructMetadataValue(context,
|
|
MetadataSchemaEnum.RELATION
|
|
.getName() + "." + relationName);
|
|
if (metadataValue != null) {
|
|
metadataValue.setAuthority(Constants.VIRTUAL_AUTHORITY_PREFIX + relationshipId);
|
|
metadataValue.setValue(otherItem.getID().toString());
|
|
metadataValue.setPlace(place);
|
|
return metadataValue;
|
|
}
|
|
return null;
|
|
}
|
|
}
|