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

Merge r5933:5935 and r5937 from nihvivo-rel-1.1-maint

Browse source
This commit is contained in:
rjy7 2010-09-24 21:35:03 +00:00
parent 715fad38f4
commit 503652796c
1 changed files with 312 additions and 147 deletions
Download patch file Download diff file Expand all files Collapse all files

429
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/EntityMergedPropertyListController.java
View file

@ -63,14 +63,14 @@ public class EntityMergedPropertyListController extends VitroHttpServlet {
private static final int MAX_GROUP_DISPLAY_RANK = 99; private static final int MAX_GROUP_DISPLAY_RANK = 99;
/** Don't include these properties in the list. */ /** Don't include these properties in the list. */
private static final Collection<String> SUPPRESSED_OBJECT_PROPERTIES = Collections private static final Collection<String> SUPPRESSED_OBJECT_PROPERTIES = Collections
.unmodifiableCollection(Arrays .unmodifiableCollection(Arrays
.asList(new String[] { VitroVocabulary.IND_MAIN_IMAGE })); .asList(new String[] { VitroVocabulary.IND_MAIN_IMAGE }));
public void doGet( HttpServletRequest request, HttpServletResponse res ) public void doGet( HttpServletRequest request, HttpServletResponse res )
throws IOException, ServletException { throws IOException, ServletException {
VitroRequest req = new VitroRequest(request); VitroRequest req = new VitroRequest(request);
try { try {
super.doGet(req, res); super.doGet(req, res);
@ -118,12 +118,12 @@ public class EntityMergedPropertyListController extends VitroHttpServlet {
List<ObjectProperty> objectPropertyList = subject.getObjectPropertyList(); List<ObjectProperty> objectPropertyList = subject.getObjectPropertyList();
for (ObjectProperty op : objectPropertyList) { for (ObjectProperty op : objectPropertyList) {
if (!SUPPRESSED_OBJECT_PROPERTIES.contains(op)) { if (!SUPPRESSED_OBJECT_PROPERTIES.contains(op)) {
op.setEditLabel(op.getDomainPublic()); op.setEditLabel(op.getDomainPublic());
mergedPropertyList.add(op); mergedPropertyList.add(op);
}else{ }else{
log.debug("suppressed " + op.getURI()); log.debug("suppressed " + op.getURI());
} }
} }
if (editMode) { if (editMode) {
@ -216,9 +216,15 @@ public class EntityMergedPropertyListController extends VitroHttpServlet {
for (Property p : g.getPropertyList()) { for (Property p : g.getPropertyList()) {
if (p instanceof ObjectProperty) { if (p instanceof ObjectProperty) {
ObjectProperty op = (ObjectProperty)p; ObjectProperty op = (ObjectProperty)p;
if (op.getObjectPropertyStatements()!=null && op.getObjectPropertyStatements().size()>0) { List<ObjectPropertyStatement> opStmts = op.getObjectPropertyStatements();
statementCount += op.getObjectPropertyStatements().size(); if (op.getObjectPropertyStatements()!=null && opStmts.size()>0) {
statementCount += opStmts.size();
// If not collated, we need to apply custom sorting now.
applyCustomSortToUncollatedProperty(op, opStmts);
} }
} }
} }
} }
@ -229,16 +235,24 @@ public class EntityMergedPropertyListController extends VitroHttpServlet {
log.error("Exception on trying to prune groups list with properties: "+ex.getMessage()); log.error("Exception on trying to prune groups list with properties: "+ex.getMessage());
} }
mergedPropertyList.clear(); mergedPropertyList.clear();
} else { // ungrouped mode
for (Property p : mergedPropertyList) {
if (p instanceof ObjectProperty) {
ObjectProperty op = (ObjectProperty)p;
applyCustomSortToUncollatedProperty(op, op.getObjectPropertyStatements());
}
}
} }
} }
if (groupedMode) { if (groupedMode) {
req.setAttribute("groupsList",groupsList); req.setAttribute("groupsList",groupsList);
} else { } else {
UnaryFunctor<List<Property>,List<Property>> entityPropertyListFilter = PropertyMaskingSetup.getEntityPropertyListFilter(getServletContext()); UnaryFunctor<List<Property>,List<Property>> entityPropertyListFilter = PropertyMaskingSetup.getEntityPropertyListFilter(getServletContext());
if (entityPropertyListFilter != null) { if (entityPropertyListFilter != null) {
mergedPropertyList = entityPropertyListFilter.fn(mergedPropertyList); mergedPropertyList = entityPropertyListFilter.fn(mergedPropertyList);
} }
req.setAttribute("mergedList",mergedPropertyList); req.setAttribute("mergedList",mergedPropertyList);
} }
@ -260,7 +274,7 @@ public class EntityMergedPropertyListController extends VitroHttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response) public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException,IOException { throws ServletException,IOException {
doGet(request, response); doGet(request, response);
} }
@ -299,7 +313,7 @@ public class EntityMergedPropertyListController extends VitroHttpServlet {
} }
switch (count) { switch (count) {
case 0: log.warn("groupsList has no groups on entering populateGroupsListWithProperties(); will create a new group \"other\""); case 0: log.warn("groupsList has no groups on entering populateGroupsListWithProperties(); will create a new group \"other\"");
break; break;
case 1: break; case 1: break;
default: try { default: try {
Collections.sort(groupsList); Collections.sort(groupsList);
@ -439,13 +453,20 @@ public class EntityMergedPropertyListController extends VitroHttpServlet {
private List<Property> collateBySubclass(List<Property> mergedPropertyList) { private List<Property> collateBySubclass(List<Property> mergedPropertyList) {
for( Property prop : mergedPropertyList){ for( Property prop : mergedPropertyList){
if( prop instanceof ObjectProperty && ((ObjectProperty)prop).getCollateBySubclass() ){ if( prop instanceof ObjectProperty ) {
collateBySubclass((ObjectProperty)prop); ObjectProperty op = (ObjectProperty) prop;
} if (op.getCollateBySubclass() ){
} log.debug("Collating property " + prop.getURI() + " by subclass");
return mergedPropertyList; collateBySubclass(op);
} } else {
}
}
}
return mergedPropertyList;
}
/** /**
* Sort the object property statements for each property so that they * Sort the object property statements for each property so that they
@ -454,128 +475,272 @@ public class EntityMergedPropertyListController extends VitroHttpServlet {
* This will be tricky since "subclass" is vaguely defined. Here directly * This will be tricky since "subclass" is vaguely defined. Here directly
* asserted classes are used. * asserted classes are used.
*/ */
private void collateBySubclass(ObjectProperty prop) { private void collateBySubclass(ObjectProperty prop) {
List<ObjectPropertyStatement> orgStmtList = prop.getObjectPropertyStatements(); List<ObjectPropertyStatement> orgStmtList = prop.getObjectPropertyStatements();
if( orgStmtList == null ) if( orgStmtList == null )
return; return;
Map<String,VClass> directClasses = getDirectClasses( getObjectsFromStmts( orgStmtList ) ); Map<String,VClass> directClasses = getDirectClasses( getObjectsFromStmts( orgStmtList ) );
//don't do collateBySubclass if there is only one class //don't do collateBySubclass if there is only one class
if( directClasses.size() < 2 ) if( directClasses.size() < 2 ) {
prop.setCollateBySubclass(false); //this overrides the value from the model prop.setCollateBySubclass(false); //this overrides the value from the model
else{ }
System.out.println("statements for object property: " + orgStmtList.size()); else{
//get list of direct classes and sort them log.debug("statements for object property: " + orgStmtList.size());
List<VClass> vclasses = new LinkedList<VClass>(directClasses.values()); //get list of direct classes and sort them
Collections.sort( List<VClass> vclasses = new LinkedList<VClass>(directClasses.values());
vclasses, Collections.sort(
new Comparator<VClass>(){ vclasses,
public int compare(VClass o1, VClass o2) { new Comparator<VClass>(){
return o1.getName().compareTo(o2.getName()); public int compare(VClass o1, VClass o2) {
} return o1.getName().compareTo(o2.getName());
}); }
});
//order object property statements by sorted direct class list //order object property statements by sorted direct class list
List<ObjectPropertyStatement> sortedStmtList = new LinkedList<ObjectPropertyStatement>(); List<ObjectPropertyStatement> sortedStmtList = new LinkedList<ObjectPropertyStatement>();
for (VClass clazz : vclasses) { for (VClass clazz : vclasses) {
// get all obj prop stmts with objects of this class // get all obj prop stmts with objects of this class
List<ObjectPropertyStatement> stmtsForClass = new ArrayList<ObjectPropertyStatement>(); List<ObjectPropertyStatement> stmtsForClass = new ArrayList<ObjectPropertyStatement>();
System.out.println("statements for object property: " + orgStmtList.size()); log.debug("statements for object property: " + orgStmtList.size());
Iterator<ObjectPropertyStatement> it = orgStmtList.iterator(); Iterator<ObjectPropertyStatement> it = orgStmtList.iterator();
while( it.hasNext()){ while( it.hasNext()){
ObjectPropertyStatement stmt = it.next(); ObjectPropertyStatement stmt = it.next();
//if (stmt.getObject().getVClasses(true).contains(clazz)) { //if (stmt.getObject().getVClasses(true).contains(clazz)) {
Individual obj = stmt.getObject(); Individual obj = stmt.getObject();
List<VClass> vclassesForObj = obj.getVClasses(true); List<VClass> vclassesForObj = obj.getVClasses(true);
if (vclassesForObj != null && vclassesForObj.contains(clazz)) { if (vclassesForObj != null && vclassesForObj.contains(clazz)) {
System.out.println("adding " + stmt + " to class " log.debug("adding " + stmt + " to class "
+ clazz.getURI()); + clazz.getURI());
System.out.println("subjectURI " + stmt.getSubjectURI() log.debug("subjectURI " + stmt.getSubjectURI()
+ " objectURI" + stmt.getObject().getURI()); + " objectURI" + stmt.getObject().getURI());
System.out.println("stmtsForclass size: " log.debug("stmtsForclass size: "
+ stmtsForClass.size()); + stmtsForClass.size());
System.out.println("stmtsForclass size: " log.debug("stmtsForclass size: "
+ stmtsForClass.size()); + stmtsForClass.size());
stmtsForClass.add(stmt); stmtsForClass.add(stmt);
} }
} }
//bdc34: What do we do if a object individual is directly asserted to two different //bdc34: What do we do if a object individual is directly asserted to two different
//types? For now we just show them in whichever type shows up first. related to NIHVIVO-876 //types? For now we just show them in whichever type shows up first. related to NIHVIVO-876
orgStmtList.removeAll(stmtsForClass); orgStmtList.removeAll(stmtsForClass);
Collections.sort(stmtsForClass, sortStatements(prop, stmtsForClass);
new Comparator<ObjectPropertyStatement>() {
public int compare(ObjectPropertyStatement o1,
ObjectPropertyStatement o2) {
return o1.getObject().getName().compareTo(
o2.getObject().getName());
}
});
System.out.println("stmtsForclass size after sort: "
+ stmtsForClass.size());
System.out.println("sortedStmtList size before add: "
+ sortedStmtList.size());
sortedStmtList.addAll(stmtsForClass);
System.out.println("sortedStmtList size after add: "
+ sortedStmtList.size());
}
prop.setObjectPropertyStatements(sortedStmtList);
}
} log.debug("stmtsForclass size after sort: "
+ stmtsForClass.size());
log.debug("sortedStmtList size before add: "
+ sortedStmtList.size());
sortedStmtList.addAll(stmtsForClass);
log.debug("sortedStmtList size after add: "
+ sortedStmtList.size());
}
prop.setObjectPropertyStatements(sortedStmtList);
}
private List<Individual> getObjectsFromStmts(List<ObjectPropertyStatement> orgStmtList) { }
List<Individual> individuals = new LinkedList<Individual>();
for( ObjectPropertyStatement stmt : orgStmtList ){
individuals.add( stmt.getObject() );
}
return individuals;
}
private Map<String,VClass> getDirectClasses(List<Individual> objectsFromStmts) { private void sortStatements(ObjectProperty prop, List<ObjectPropertyStatement> statements) {
Map<String,VClass> directClasses = new HashMap<String,VClass>();
for (Individual ind : objectsFromStmts) { if (!applyCustomSort(prop, statements)) {
for (VClass clazz : ind.getVClasses(true)) { Collections.sort(statements,
directClasses.put(clazz.getURI(),clazz); new Comparator<ObjectPropertyStatement>() {
} public int compare(ObjectPropertyStatement o1,
} ObjectPropertyStatement o2) {
return directClasses; return o1.getObject().getName().compareTo(
} o2.getObject().getName());
}
});
}
}
/** // rjy7 Quick and dirty fix to achieve custom sorting for specific properties in the VIVO ontology.
* Look for filter in servlet context and filter properties with it if there is one. // See NIHVIVO-426, NIHVIVO-1158, NIHVIVO-1160. Some of these involve sorting on data properties of an
* // individual two graph edges away from the individual being displayed, for which there is currently
* This allows a vitro instance to have specialized filtering for display. It was originally // no provision. A better strategy will be designed and implemented in a later version, in particular
* created to deal with problems caused by custom short views. // one that does not involve hard-coded references to the VIVO ontology in the Vitro core.
* * private boolean applyCustomSort(ObjectProperty prop, List<ObjectPropertyStatement> statements) {
* @param objectPropertyList
* @param wdf
* @return
*/
private Individual filterFromContext(Individual ind ) {
try{
UnaryFunctor<Individual,Individual> filter = getMergedPropertyListFilter(getServletContext());
if( filter == null )
return ind;
else
return filter.fn(ind);
}catch(Throwable t){
log.error(t,t);
}
return ind;
}
public static void setMergedPropertyListFilter( UnaryFunctor<Individual,Individual>fn, ServletContext sc){ String vivoCoreOntology = "http://vivoweb.org/ontology/core#";
sc.setAttribute("EntityMergedPropertyListController.toFilteringIndividual", fn); String propertyUri = prop.getURI();
}
public static UnaryFunctor<Individual,Individual> getMergedPropertyListFilter( ServletContext sc){ // Positions in an organization
return(UnaryFunctor<Individual,Individual>)sc.getAttribute("EntityMergedPropertyListController.toFilteringIndividual"); if (propertyUri.equals(vivoCoreOntology + "organizationForPosition")) {
} sortByRelatedIndividualNames(statements, vivoCoreOntology + "positionForPerson");
return true;
}
// Person's positions
if (propertyUri.equals(vivoCoreOntology + "personInPosition")) {
sortReverseChron(statements, vivoCoreOntology + "endYear", vivoCoreOntology + "startYear");
return true;
}
// // Person's publications
// if (propertyUri.equals(vivoCoreOntology + "authorInAuthorship")) {
// sortByReverseChronAndRelatedIndividualName(statements, vivoCoreOntology + " ", vivoCoreOntology + " ");
// return true;
// }
return false;
}
// Apply custom sorting to an uncollated property. If the property is collated, the custom sorting has already
// been applied to each subclass listing individually.
private void applyCustomSortToUncollatedProperty(ObjectProperty op, List<ObjectPropertyStatement> opStmts) {
// This includes the case where the ontology doesn't specify collating, as well as the case
// where we don't collate because only one subclass is populated, since then we've set
// the collation value to false.
if (!op.getCollateBySubclass()) {
if (applyCustomSort(op, opStmts)) {
op.setObjectPropertyStatements(opStmts);
}
}
}
private void sortReverseChron(List<ObjectPropertyStatement> statements, String endYearPredicate, String startYearPredicate) {
// 1. Sort by end date descending, null dates first
// 2. Then by start date descending, null dates last
// 3. No sorting for entries with no start or end date - just put at the bottom in random order
final String endYearProperty = endYearPredicate;
final String startYearProperty = startYearPredicate;
Collections.sort(statements, new Comparator<ObjectPropertyStatement>() {
public int compare(ObjectPropertyStatement left, ObjectPropertyStatement right) {
String endLeftValue = left.getObject().getDataValue(endYearProperty);
Integer endLeft = endLeftValue == null ? null : Integer.valueOf(endLeftValue);
String startLeftValue = left.getObject().getDataValue(startYearProperty);
Integer startLeft = startLeftValue == null ? null : Integer.valueOf(startLeftValue);
String endRightValue = right.getObject().getDataValue(endYearProperty);
Integer endRight = endRightValue == null ? null : Integer.valueOf(endRightValue);
String startRightValue = right.getObject().getDataValue(startYearProperty);
Integer startRight = startRightValue == null ? null : Integer.valueOf(startRightValue);
// No sorting for entries with no start or end date - just put at the bottom in random order
if (endLeft == null && startLeft == null) {
return 1;
}
if (endRight == null && startRight == null) {
return -1;
}
// First sort by end date
// A null end date precedes
// But if both end dates are null, compare start dates
if ( ! (endLeft == null && endRight == null) ) {
if (endLeft == null) {
return -1;
}
if (endRight == null) {
return 1;
}
int endComp = endLeft.compareTo(endRight);
if (endComp != 0) {
return 0 - endComp;
}
}
// If end dates are equal, sort by start date
// A null start date follows
if (startLeft == null) {
return 1;
}
if (startRight == null) {
return -1;
}
return 0 - startLeft.compareTo(startRight);
}
});
}
// private void sortByReverseChronAndRelatedIndividualName(List<ObjectPropertyStatement> statements,
// String datePredicate, String relatedIndividualPredicate) {
//
// }
// Sort statements by the name of the individual on the other side of the context node.
private void sortByRelatedIndividualNames(List<ObjectPropertyStatement> statements, String predicateUri) {
log.debug("In sortByRelatedIndividualNames(), before sorting");
if (log.isDebugEnabled()) {
for (ObjectPropertyStatement ops : statements) {
log.debug(ops.getObject().getRelatedIndividual(predicateUri).getName());
}
}
final String propertyUri = predicateUri;
Collections.sort(statements, new Comparator<ObjectPropertyStatement>() {
public int compare(ObjectPropertyStatement left, ObjectPropertyStatement right) {
Individual indLeft = left.getObject().getRelatedIndividual(propertyUri);
Individual indRight = right.getObject().getRelatedIndividual(propertyUri);
return indLeft.getName().compareTo(indRight.getName());
}
});
log.debug("In sortByRelatedIndividualNames(), after sorting");
if (log.isDebugEnabled()) {
for (ObjectPropertyStatement ops : statements) {
log.debug(ops.getObject().getRelatedIndividual(predicateUri).getName());
}
}
}
private List<Individual> getObjectsFromStmts(List<ObjectPropertyStatement> orgStmtList) {
List<Individual> individuals = new LinkedList<Individual>();
for( ObjectPropertyStatement stmt : orgStmtList ){
individuals.add( stmt.getObject() );
}
return individuals;
}
private Map<String,VClass> getDirectClasses(List<Individual> objectsFromStmts) {
Map<String,VClass> directClasses = new HashMap<String,VClass>();
for (Individual ind : objectsFromStmts) {
for (VClass clazz : ind.getVClasses(true)) {
directClasses.put(clazz.getURI(),clazz);
}
}
return directClasses;
}
/**
* Look for filter in servlet context and filter properties with it if there is one.
*
* This allows a vitro instance to have specialized filtering for display. It was originally
* created to deal with problems caused by custom short views.
* *
* @param objectPropertyList
* @param wdf
* @return
*/
private Individual filterFromContext(Individual ind ) {
try{
UnaryFunctor<Individual,Individual> filter = getMergedPropertyListFilter(getServletContext());
if( filter == null )
return ind;
else
return filter.fn(ind);
}catch(Throwable t){
log.error(t,t);
}
return ind;
}
public static void setMergedPropertyListFilter( UnaryFunctor<Individual,Individual>fn, ServletContext sc){
sc.setAttribute("EntityMergedPropertyListController.toFilteringIndividual", fn);
}
public static UnaryFunctor<Individual,Individual> getMergedPropertyListFilter( ServletContext sc){
return(UnaryFunctor<Individual,Individual>)sc.getAttribute("EntityMergedPropertyListController.toFilteringIndividual");
}
} }