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

Merge branch 'develop' of https://github.com/vivo-project/Vitro into develop

Browse source
This commit is contained in:
brianjlowe 2015-02-11 16:50:41 +02:00
commit 86d4ed6506
15 changed files with 178 additions and 91 deletions
Download patch file Download diff file Expand all files Collapse all files

1
webapp/src/edu/cornell/mannlib/vitro/webapp/migration/Release18Migrator.java
View file

@ -16,6 +16,7 @@ public class Release18Migrator implements ServletContextListener {
ServletContext ctx = sce.getServletContext();
new FauxPropertiesUpdater(ctx, this).migrate();
new RemoveObsoleteMetadataGraphs(ctx, this).migrate();
}
@Override

67
webapp/src/edu/cornell/mannlib/vitro/webapp/migration/RemoveObsoleteMetadataGraphs.java Normal file
View file

@ -0,0 +1,67 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.migration;
import static edu.cornell.mannlib.vitro.webapp.modelaccess.ModelAccess.WhichService.CONFIGURATION;
import static edu.cornell.mannlib.vitro.webapp.modelaccess.ModelAccess.WhichService.CONTENT;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextListener;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import edu.cornell.mannlib.vitro.webapp.modelaccess.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.modelaccess.ModelAccess.WhichService;
import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.jena.RDFServiceJena;
import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus;
/**
* The graphs http://vitro.mannlib.cornell.edu/ns/vitro/sdb/metadata were used
* in Content models through release 1.7 and in Configuration models in release
* 1.7
*
* In release 1.8, they area no longer used, and produce annoying warning
* messages.
*/
public class RemoveObsoleteMetadataGraphs {
private static final String OBSOLETE_METADATA_MODEL = "http://vitro.mannlib.cornell.edu/ns/vitro/sdb/metadata";
private final ServletContext ctx;
private final ServletContextListener parent;
public RemoveObsoleteMetadataGraphs(ServletContext ctx,
ServletContextListener parent) {
this.ctx = ctx;
this.parent = parent;
}
public void migrate() {
StartupStatus ss = StartupStatus.getBean(ctx);
removeMetadataModel(ctx, ss, CONTENT);
removeMetadataModel(ctx, ss, CONFIGURATION);
}
/**
* Ordinarily, RDFServiceJena will issue a warning when a single triple is
* removed from a blank node. In this case, however, that's exactly what we
* want, so stifle those warnings while we remove these models.
*/
private void removeMetadataModel(ServletContext ctx, StartupStatus ss,
WhichService which) {
Logger rdfServiceLogger = Logger.getLogger(RDFServiceJena.class);
Level rdfServiceLogLevel = rdfServiceLogger.getLevel();
rdfServiceLogger.setLevel(Level.ERROR);
try {
ModelAccess.on(ctx).getModelMaker(which)
.removeModel(OBSOLETE_METADATA_MODEL);
} catch (Exception e) {
ss.warning(parent, "Failed to remove '" + OBSOLETE_METADATA_MODEL
+ "' from " + which, e);
} finally {
rdfServiceLogger.setLevel(rdfServiceLogLevel);
}
}
}

2
webapp/src/edu/cornell/mannlib/vitro/webapp/searchindex/SearchIndexerImpl.java
View file

@ -374,7 +374,7 @@ public class SearchIndexerImpl implements SearchIndexer {
private final TaskQueue taskQueue;
private final List<Task> deferredQueue;
private volatile boolean started;
private volatile boolean paused = true;
private volatile boolean paused;
public Scheduler(TaskQueue taskQueue) {
this.taskQueue = taskQueue;

77
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.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
@ -139,39 +140,31 @@ public class CollatedObjectPropertyTemplateModel extends
// others will be removed
List<Map<String, String>> filteredList = new ArrayList<Map<String, 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) {
String objectUri = outerMap.get(objectVariableName);
if (processedObjects.contains(objectUri)) {
continue;
}
processedObjects.add(objectUri);
//Get most specific type for this particular
List<String> mostSpecificTypes = this.getSortedMostSpecificType(objectUri);
//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
List<Map<String, String>> dataForThisObject = new ArrayList<Map<String, String>>();
//Retrieve the statements that are related to this specific object
for (Map<String, String> innerMap : statementData) {
//Check both the object uri and that the subclass returned matches
//the most specific type
if (innerMap.get(objectVariableName) == objectUri) {
//At this point, the statement data will already have the most specific type
//represented
String subclass = innerMap.get(SUBCLASS_VARIABLE_NAME);
if(mostSpecificTypes.contains(subclass)) {
filteredList.add(innerMap);
filteredObjects.add(objectUri);
} else {
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());
}
}
if (innerMap.get(objectVariableName).equals(objectUri)) {
// Subclass should at this point contain the most specific
// type already
dataForThisObject.add(innerMap);
}
}
if(log.isDebugEnabled()) {
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));
}
statementData.retainAll(filteredList);
@ -179,33 +172,25 @@ public class CollatedObjectPropertyTemplateModel extends
if (log.isDebugEnabled()) {
log.debug("Data after subclass filtering");
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
//An alternative would be to ensure that the default form, or any form that utilizes collation
//will return most specific type within the listview select/construct queries so the resulting
//statement data has that value
List<String> getMostSpecificTypesForObject(String objectURI) {
WebappDaoFactory wadf = ModelAccess.on(vreq).getWebappDaoFactory();
return wadf.getIndividualDao().getIndividualByURI(objectURI).getMostSpecificTypeURIs();
//Subclass variable should already contain most specific type
//If there is more than one most specific type, then order alphabetically
private class DataComparatorBySubclass implements
Comparator<Map<String, String>> {
@Override
public int compare(Map<String, String> map1, Map<String, String> map2) {
String subclass1 = map1.get(SUBCLASS_VARIABLE_NAME);
String subclass2 = map2.get(SUBCLASS_VARIABLE_NAME);
return subclass1.compareTo(subclass2);
}
}
//This will return a single most specific type for an object
//If there are multiple most specific types, the list will be sorted alphabetically and
//the first one will be returned
List<String> getSortedMostSpecificType(String objectURI) {
List<String> mostSpecificTypeURIs = this.getMostSpecificTypesForObject(objectURI);
Collections.sort(mostSpecificTypeURIs);
return mostSpecificTypeURIs;
}
// Collate the statements by subclass.

25
webapp/src/edu/cornell/mannlib/vitro/webapp/web/templatemodels/individual/DataPropertyTemplateModel.java
View file

@ -65,6 +65,7 @@ public class DataPropertyTemplateModel extends PropertyTemplateModel {
private String objectKey;
private String queryString;
private Set<String> constructQueries;
private int displayLimit;
DataPropertyTemplateModel(DataProperty dp, Individual subject, VitroRequest vreq,
boolean editing, List<DataProperty> populatedDataPropertyList) {
@ -82,7 +83,7 @@ public class DataPropertyTemplateModel extends PropertyTemplateModel {
constructQueries = getConstructQueries();
statements = new ArrayList<DataPropertyStatementTemplateModel>();
displayLimit = dp.getDisplayLimit();
// If the property is populated, get the data property statements via a sparql query
if (populatedDataPropertyList.contains(dp)) {
log.debug("Getting data for populated data property " + getUri());
@ -108,14 +109,22 @@ public class DataPropertyTemplateModel extends PropertyTemplateModel {
return;
}
// If the display limit has already been reached, we can't add a new statement.
// NB This appears to be a misuse of a value called "display limit". Note that it's
// not used to limit display, either, so should be renamed.
/* If the display limit has already been reached, we can't add a new statement.
NB This appears to be a misuse of a value called "display limit". Note that it's
not used to limit display, either, so should be renamed.
int displayLimit = dp.getDisplayLimit();
// Display limit of -1 (default value for new property) means no display limit
Display limit of -1 (default value for new property) means no display limit
if ( displayLimit >= 0 && statements.size() >= displayLimit ) {
return;
}
*/
// Rewriting the above per jc55. If the data property is functional, there should only
// be 1 statement. The Display Limit is for determining how many statements to display
// before a "more..." link is used to hide statements exceeding the display limit. tlw72
boolean functional = dp.getFunctional();
if ( functional && statements.size() >= 1 ) {
return;
}
// Determine whether a new statement can be added
RequestedAction action = new AddDataPropertyStatement(
@ -146,6 +155,11 @@ public class DataPropertyTemplateModel extends PropertyTemplateModel {
protected Route getPropertyEditRoute() {
return Route.DATA_PROPERTY_EDIT;
}
@Override
public int getDisplayLimit() {
return displayLimit;
}
public ConfigError checkQuery(String queryString) {
if (StringUtils.isBlank(queryString)) {
@ -191,6 +205,7 @@ public class DataPropertyTemplateModel extends PropertyTemplateModel {
public String getTemplate() {
return getTemplateName();
}
/* Template methods */

7
webapp/src/edu/cornell/mannlib/vitro/webapp/web/templatemodels/individual/PropertyTemplateModel.java
View file

@ -41,6 +41,7 @@ public abstract class PropertyTemplateModel extends BaseTemplateModel {
private String name;
private FauxProperty fauxProperty;
private int displayLimit;
PropertyTemplateModel(Property property, Individual subject, VitroRequest vreq, String name) {
this.vreq = vreq;
@ -49,11 +50,13 @@ public abstract class PropertyTemplateModel extends BaseTemplateModel {
propertyUri = property.getURI();
localName = property.getLocalName();
this.name = name;
this.displayLimit = displayLimit;
addUrl = "";
fauxProperty = isFauxProperty(property);
if (fauxProperty != null) {
this.name = fauxProperty.getDisplayName();
this.displayLimit = fauxProperty.getDisplayLimit();
}
setVerboseDisplayValues(property);
@ -142,6 +145,10 @@ public abstract class PropertyTemplateModel extends BaseTemplateModel {
return name;
}
public int getDisplayLimit() {
return displayLimit;
}
public String getLocalName() {
return localName;
}