litvinovg/vitro
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

VIVO-957 updating to utilize subclass variable which is now most specific type

Browse source
This commit is contained in:
hudajkhan 2015-02-10 14:23:50 -05:00
parent b21cd24489
commit f9361f4cd6
1 changed files with 31 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

71
webapp/src/edu/cornell/mannlib/vitro/webapp/web/templatemodels/individual/CollatedObjectPropertyTemplateModel.java
View file

@ -5,6 +5,7 @@ package edu.cornell.mannlib.vitro.webapp.web.templatemodels.individual;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.Comparator; import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -139,38 +140,30 @@ public class CollatedObjectPropertyTemplateModel extends
// others will be removed // others will be removed
List<Map<String, String>> filteredList = new ArrayList<Map<String, String>>(); List<Map<String, String>> filteredList = new ArrayList<Map<String, String>>();
Set<String> processedObjects = new HashSet<String>(); Set<String> processedObjects = new HashSet<String>();
//Useful to keep track of objects where statement data may not match the most specific type
//returne for some reason, in which case useful to keep track
Set<String> filteredObjects = new HashSet<String>();
for (Map<String, String> outerMap : statementData) { for (Map<String, String> outerMap : statementData) {
String objectUri = outerMap.get(objectVariableName); String objectUri = outerMap.get(objectVariableName);
if (processedObjects.contains(objectUri)) { if (processedObjects.contains(objectUri)) {
continue; continue;
} }
processedObjects.add(objectUri); processedObjects.add(objectUri);
//Get most specific type for this particular List<Map<String, String>> dataForThisObject = new ArrayList<Map<String, String>>();
List<String> mostSpecificTypes = this.getSortedMostSpecificType(objectUri); //Retrieve the statements that are related to this specific object
//If more than one most specific type, will compare against both of them
//and if the first one matches, the object will be placed under that
//otherwise subclass will be checked against the other
for (Map<String, String> innerMap : statementData) { for (Map<String, String> innerMap : statementData) {
//Check both the object uri and that the subclass returned matches if (innerMap.get(objectVariableName).equals(objectUri)) {
//the most specific type // Subclass should at this point contain the most specific
if (innerMap.get(objectVariableName) == objectUri) { // type already
//At this point, the statement data will already have the most specific type dataForThisObject.add(innerMap);
//represented }
String subclass = innerMap.get(SUBCLASS_VARIABLE_NAME); }
if(mostSpecificTypes.contains(subclass)) {
filteredList.add(innerMap);
filteredObjects.add(objectUri);
} else {
if(log.isDebugEnabled()) { if(log.isDebugEnabled()) {
log.debug("Iterating through statement data, Subclass does not match most specific type for Object URI - " + objectUri + " - subclass:" + subclass + " - most specific types=" + mostSpecificTypes.toString()); log.debug("Object URI " + objectUri + " has number of statements = " + dataForThisObject.size());
}
}
}
} }
//Subclass variable should already reflect most specifick types but there may be more than one most specific type
Collections.sort(dataForThisObject, new DataComparatorBySubclass());
filteredList.add(dataForThisObject.get(0));
} }
@ -179,31 +172,23 @@ public class CollatedObjectPropertyTemplateModel extends
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Data after subclass filtering"); log.debug("Data after subclass filtering");
logData(statementData); logData(statementData);
//check and see if filteredObjects and processedObjects not the same size
if(filteredObjects.size() < processedObjects.size()) {
log.debug("Certain objects not included in statements displayed for collated subclasses");
processedObjects.removeAll(filteredObjects);
log.debug("These object uris not represented" + processedObjects.toString());
}
} }
} }
//Get the most specific type //Subclass variable should already contain most specific type
//An alternative would be to ensure that the default form, or any form that utilizes collation //If there is more than one most specific type, then order alphabetically
//will return most specific type within the listview select/construct queries so the resulting private class DataComparatorBySubclass implements
//statement data has that value Comparator<Map<String, String>> {
List<String> getMostSpecificTypesForObject(String objectURI) {
WebappDaoFactory wadf = ModelAccess.on(vreq).getWebappDaoFactory();
return wadf.getIndividualDao().getIndividualByURI(objectURI).getMostSpecificTypeURIs();
}
//This will return a single most specific type for an object @Override
//If there are multiple most specific types, the list will be sorted alphabetically and public int compare(Map<String, String> map1, Map<String, String> map2) {
//the first one will be returned
List<String> getSortedMostSpecificType(String objectURI) { String subclass1 = map1.get(SUBCLASS_VARIABLE_NAME);
List<String> mostSpecificTypeURIs = this.getMostSpecificTypesForObject(objectURI); String subclass2 = map2.get(SUBCLASS_VARIABLE_NAME);
Collections.sort(mostSpecificTypeURIs);
return mostSpecificTypeURIs; return subclass1.compareTo(subclass2);
}
} }