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

SDB implementation of RDF API (and merge from trunk)

Browse source
This commit is contained in:
brianjlowe 2012-06-04 21:09:36 +00:00
parent 8aa257d564
commit cead502f89
194 changed files with 10522 additions and 5324 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
webapp/build.xml
View file

@ -12,7 +12,7 @@
<!-- - - - - - - - - - - - - - - - - - <!-- - - - - - - - - - - - - - - - - -
properties properties
- - - - - - - - - - - - - - - - - --> - - - - - - - - - - - - - - - - -->
<dirname property="corebase.dir" file="${ant.file.vitroCore}" /> <dirname property="corebase.dir" file="${ant.file.vitroCore}" />
<!-- A product script will override appbase.dir, but not corebase.dir --> <!-- A product script will override appbase.dir, but not corebase.dir -->

5
webapp/config/default.log4j.properties
View file

@ -33,10 +33,15 @@ log4j.appender.AllAppender.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS}
log4j.rootLogger=INFO, AllAppender log4j.rootLogger=INFO, AllAppender
# These classes are too chatty to display INFO messages.
log4j.logger.edu.cornell.mannlib.vitro.webapp.startup.StartupStatus=WARN log4j.logger.edu.cornell.mannlib.vitro.webapp.startup.StartupStatus=WARN
log4j.logger.edu.cornell.mannlib.vitro.webapp.controller.freemarker.BrowseController=WARN log4j.logger.edu.cornell.mannlib.vitro.webapp.controller.freemarker.BrowseController=WARN
log4j.logger.edu.cornell.mannlib.vitro.webapp.dao.jena.pellet.PelletListener=WARN log4j.logger.edu.cornell.mannlib.vitro.webapp.dao.jena.pellet.PelletListener=WARN
log4j.logger.edu.cornell.mannlib.vitro.webapp.dao.jena.RDBGraphGenerator=WARN log4j.logger.edu.cornell.mannlib.vitro.webapp.dao.jena.RDBGraphGenerator=WARN
# Spring as a whole is too chatty to display INFO messages.
log4j.logger.org.springframework=WARN
# suppress odd warnings from libraries # suppress odd warnings from libraries
log4j.logger.com.hp.hpl.jena.sdb.layout2.LoaderTuplesNodes=FATAL log4j.logger.com.hp.hpl.jena.sdb.layout2.LoaderTuplesNodes=FATAL
log4j.logger.com.hp.hpl.jena.db.impl.PSet_TripleStore_RDB=FATAL log4j.logger.com.hp.hpl.jena.db.impl.PSet_TripleStore_RDB=FATAL

BIN
webapp/lib/commons-beanutils.jar Normal file
View file

Binary file not shown.

BIN
webapp/lib/ezmorph-1.0.4.jar Normal file
View file

Binary file not shown.

BIN
webapp/lib/json-lib-2.2.2-jdk15.jar Normal file
View file

Binary file not shown.

5
webapp/src/edu/cornell/mannlib/vitro/webapp/beans/Individual.java
View file

@ -3,15 +3,12 @@
package edu.cornell.mannlib.vitro.webapp.beans; package edu.cornell.mannlib.vitro.webapp.beans;
import java.sql.Timestamp; import java.sql.Timestamp;
import java.util.Date;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import org.json.JSONException; import org.json.JSONException;
import org.json.JSONObject; import org.json.JSONObject;
import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch;
/** /**
* User: bdc34 * User: bdc34
* Date: Oct 18, 2007 * Date: Oct 18, 2007
@ -71,8 +68,6 @@ public interface Individual extends ResourceBean, Comparable<Individual> {
/** Does the individual belong to this class? */ /** Does the individual belong to this class? */
boolean isVClass(String uri); boolean isVClass(String uri);
public boolean isMemberOfClassProhibitedFromSearch(ProhibitedFromSearch pfs);
void setObjectPropertyStatements(List<ObjectPropertyStatement> list); void setObjectPropertyStatements(List<ObjectPropertyStatement> list);
List<ObjectPropertyStatement> getObjectPropertyStatements(); List<ObjectPropertyStatement> getObjectPropertyStatements();
List<ObjectPropertyStatement> getObjectPropertyStatements(String propertyUri); List<ObjectPropertyStatement> getObjectPropertyStatements(String propertyUri);

5
webapp/src/edu/cornell/mannlib/vitro/webapp/beans/IndividualImpl.java
View file

@ -193,11 +193,6 @@ public class IndividualImpl extends BaseResourceBean implements Individual, Comp
return false; return false;
} }
public boolean isMemberOfClassProhibitedFromSearch(ProhibitedFromSearch pfs) {
throw new UnsupportedOperationException(this.getClass().getName() +
".isMemberOfClassProhibitedFromSearch must be overriden by a subclass");
}
public List<VClass> getVClasses(boolean direct) { public List<VClass> getVClasses(boolean direct) {
if (direct) { if (direct) {
return directVClasses; return directVClasses;

9
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/BasicSmokeTests.java → webapp/src/edu/cornell/mannlib/vitro/webapp/config/ConfigurationPropertiesSmokeTests.java
View file

@ -1,6 +1,6 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */ /* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.servlet.setup; package edu.cornell.mannlib.vitro.webapp.config;
import java.io.File; import java.io.File;
import java.sql.Connection; import java.sql.Connection;
@ -12,10 +12,13 @@ import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener; import javax.servlet.ServletContextListener;
import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties;
import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus; import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus;
public class BasicSmokeTests implements ServletContextListener { /**
* Test that gets run at servlet context startup to check for the existence and
* validity of properties in the configuration.
*/
public class ConfigurationPropertiesSmokeTests implements ServletContextListener {
private static final String PROPERTY_HOME_DIRECTORY = "vitro.home.directory"; private static final String PROPERTY_HOME_DIRECTORY = "vitro.home.directory";
private static final String PROPERTY_DB_URL = "VitroConnection.DataSource.url"; private static final String PROPERTY_DB_URL = "VitroConnection.DataSource.url";

587
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/JsonServlet.java
View file

@ -1,587 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.rdf.model.Literal;
import edu.cornell.mannlib.vitro.webapp.beans.DataProperty;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.beans.VClassGroup;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.IndividualListController;
import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.ObjectPropertyStatementDao;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VClassGroupCache;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.EditConfiguration;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.SelectListGenerator;
import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch;
import edu.cornell.mannlib.vitro.webapp.utils.pageDataGetter.PageDataGetterUtils;
import static edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary.DISPLAY_ONT_MODEL;
/**
* This servlet is for servicing requests for JSON objects/data.
* It could be generalized to get other types of data ex. XML, HTML etc
* @author bdc34
*
*/
public class JsonServlet extends VitroHttpServlet {
private static final long serialVersionUID = 1L;
private static final Log log = LogFactory.getLog(JsonServlet.class);
private static final int REPLY_SIZE = 256;
private static final int INDIVIDUALS_PER_PAGE = 30;
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doGet(req, resp);
VitroRequest vreq = new VitroRequest(req);
try{
if(vreq.getParameter("getEntitiesByVClass") != null ){
if( vreq.getParameter("resultKey") == null) {
getEntitiesByVClass(req, resp);
return;
} else {
getEntitiesByVClassContinuation( req, resp);
return;
}
}else if( vreq.getParameter("getN3EditOptionList") != null ){
doN3EditOptionList(req,resp);
return;
}else if( vreq.getParameter("getSolrIndividualsByVClass") != null ){
getSolrIndividualsByVClass(req,resp);
return;
}else if( vreq.getParameter("getVClassesForVClassGroup") != null ){
getVClassesForVClassGroup(req,resp);
return;
} else if( vreq.getParameter("getSolrIndividualsByVClasses") != null ){
log.debug("AJAX request to retrieve individuals by vclasses");
getSolrIndividualsByVClasses(req,resp);
return;
} else if( vreq.getParameter("getDataForPage") != null ){
getDataForPage(req,resp);
return;
}
}catch(Exception ex){
log.warn(ex,ex);
}
}
private void getVClassesForVClassGroup(HttpServletRequest req, HttpServletResponse resp) throws IOException, JSONException {
JSONObject map = new JSONObject();
VitroRequest vreq = new VitroRequest(req);
String vcgUri = vreq.getParameter("classgroupUri");
if( vcgUri == null ){
log.debug("no URI passed for classgroupUri");
resp.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
return;
}
VClassGroupCache vcgc = VClassGroupCache.getVClassGroupCache(getServletContext());
VClassGroup vcg = vcgc.getGroup(vcgUri);
if( vcg == null ){
log.debug("Could not find vclassgroup: " + vcgUri);
resp.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
return;
}
ArrayList<JSONObject> classes = new ArrayList<JSONObject>(vcg.size());
for( VClass vc : vcg){
JSONObject vcObj = new JSONObject();
vcObj.put("name", vc.getName());
vcObj.put("URI", vc.getURI());
vcObj.put("entityCount", vc.getEntityCount());
classes.add(vcObj);
}
map.put("classes", classes);
map.put("classGroupName", vcg.getPublicName());
map.put("classGroupUri", vcg.getURI());
resp.setCharacterEncoding("UTF-8");
resp.setContentType("application/json;charset=UTF-8");
Writer writer = resp.getWriter();
writer.write(map.toString());
}
private void getSolrIndividualsByVClass( HttpServletRequest req, HttpServletResponse resp ){
String errorMessage = null;
JSONObject rObj = null;
try{
VitroRequest vreq = new VitroRequest(req);
VClass vclass=null;
String vitroClassIdStr = vreq.getParameter("vclassId");
if ( vitroClassIdStr != null && !vitroClassIdStr.isEmpty()){
vclass = vreq.getWebappDaoFactory().getVClassDao().getVClassByURI(vitroClassIdStr);
if (vclass == null) {
log.debug("Couldn't retrieve vclass ");
throw new Exception (errorMessage = "Class " + vitroClassIdStr + " not found");
}
}else{
log.debug("parameter vclassId URI parameter expected ");
throw new Exception("parameter vclassId URI parameter expected ");
}
vreq.setAttribute("displayType", vitroClassIdStr);
rObj = getSolrIndividualsByVClass(vclass.getURI(),req, getServletContext());
}catch(Exception ex){
errorMessage = ex.toString();
log.error(ex,ex);
}
if( rObj == null )
rObj = new JSONObject();
try{
resp.setCharacterEncoding("UTF-8");
resp.setContentType("application/json;charset=UTF-8");
if( errorMessage != null ){
rObj.put("errorMessage", errorMessage);
resp.setStatus(500 /*HttpURLConnection.HTTP_SERVER_ERROR*/);
}else{
rObj.put("errorMessage", "");
}
Writer writer = resp.getWriter();
writer.write(rObj.toString());
}catch(JSONException jse){
log.error(jse,jse);
} catch (IOException e) {
log.error(e,e);
}
}
public static JSONObject getSolrIndividualsByVClass(String vclassURI, HttpServletRequest req, ServletContext context) throws Exception {
List<String> vclassURIs = new ArrayList<String>();
vclassURIs.add(vclassURI);
VitroRequest vreq = new VitroRequest(req);
VClass vclass=null;
JSONObject rObj = new JSONObject();
Map<String, Object> map = getSolrVClassIntersectionResults(vclassURIs, vreq, context);
//last parameter indicates single vclass instead of multiple vclasses
rObj = processVClassResults(map, vreq, context, false);
return rObj;
}
// Accepts multiple vclasses and returns individuals which correspond to the intersection of those classes (i.e. have all those types)
private void getSolrIndividualsByVClasses( HttpServletRequest req, HttpServletResponse resp ){
log.debug("Executing retrieval of individuals by vclasses");
String errorMessage = null;
JSONObject rObj = null;
try{
VitroRequest vreq = new VitroRequest(req);
VClass vclass=null;
log.debug("Retrieving solr individuals by vclasses");
// Could have multiple vclass ids sent in
String[] vitroClassIdStr = vreq.getParameterValues("vclassId");
if ( vitroClassIdStr != null && vitroClassIdStr.length > 0){
for(String vclassId: vitroClassIdStr) {
log.debug("Iterating throug vclasses, using VClass " + vclassId);
vclass = vreq.getWebappDaoFactory().getVClassDao().getVClassByURI(vclassId);
if (vclass == null) {
log.error("Couldn't retrieve vclass ");
throw new Exception (errorMessage = "Class " + vclassId + " not found");
}
}
}else{
log.error("parameter vclassId URI parameter expected but not found");
throw new Exception("parameter vclassId URI parameter expected ");
}
List<String> vclassIds = Arrays.asList(vitroClassIdStr);
rObj = getSolrIndividualsByVClasses(vclassIds,req, getServletContext());
}catch(Exception ex){
errorMessage = ex.toString();
log.error(ex,ex);
}
if( rObj == null )
rObj = new JSONObject();
try{
resp.setCharacterEncoding("UTF-8");
resp.setContentType("application/json;charset=UTF-8");
if( errorMessage != null ){
rObj.put("errorMessage", errorMessage);
resp.setStatus(500 /*HttpURLConnection.HTTP_SERVER_ERROR*/);
}else{
rObj.put("errorMessage", "");
}
Writer writer = resp.getWriter();
writer.write(rObj.toString());
}catch(JSONException jse){
log.error(jse,jse);
} catch (IOException e) {
log.error(e,e);
}
}
public static JSONObject getSolrIndividualsByVClasses(List<String> vclassURIs, HttpServletRequest req, ServletContext context) throws Exception {
VitroRequest vreq = new VitroRequest(req);
log.debug("Retrieve solr results for vclasses" + vclassURIs.toString());
Map<String, Object> map = getSolrVClassIntersectionResults(vclassURIs, vreq, context);
log.debug("Results returned from Solr for " + vclassURIs.toString() + " are of size " + map.size());
JSONObject rObj = processVClassResults(map, vreq, context, true);
return rObj;
}
//Including version for Solr query for Vclass Intersections
private static Map<String,Object> getSolrVClassIntersectionResults(List<String> vclassURIs, VitroRequest vreq, ServletContext context){
log.debug("Retrieving Solr intersection results for " + vclassURIs.toString());
String alpha = IndividualListController.getAlphaParameter(vreq);
int page = IndividualListController.getPageParameter(vreq);
log.debug("Alpha and page parameters are " + alpha + " and " + page);
Map<String,Object> map = null;
try {
map = IndividualListController.getResultsForVClassIntersections(
vclassURIs,
page, INDIVIDUALS_PER_PAGE,
alpha,
vreq.getWebappDaoFactory().getIndividualDao(),
context);
} catch(Exception ex) {
log.error("Error in retrieval of search results for VClass " + vclassURIs.toString(), ex);
}
return map;
}
// Map given to process method includes the actual individuals returned from the search
public static JSONObject processVClassResults(Map<String, Object> map, VitroRequest vreq, ServletContext context, boolean multipleVclasses) throws Exception{
JSONObject rObj = PageDataGetterUtils.processVclassResultsJSON(map, vreq, multipleVclasses);
return rObj;
}
public static Collection<String> getMostSpecificTypes(Individual individual, WebappDaoFactory wdf) {
ObjectPropertyStatementDao opsDao = wdf.getObjectPropertyStatementDao();
Map<String, String> mostSpecificTypes = opsDao.getMostSpecificTypesInClassgroupsForIndividual(individual.getURI());
return mostSpecificTypes.values();
}
public static String getDataPropertyValue(Individual ind, DataProperty dp, WebappDaoFactory wdf){
String value = ind.getDataValue(dp.getURI());
if( value == null || value.isEmpty() )
return "";
else
return value;
}
/**
* Gets an option list for a given EditConfiguration and Field.
* Requires following HTTP query parameters:
* editKey
* field
*/
private void doN3EditOptionList(HttpServletRequest req, HttpServletResponse resp) throws IOException {
log.debug("in doN3EditOptionList()");
String field = req.getParameter("field");
if( field == null ){
log.debug("could not find query parameter 'field' for doN3EditOptionList");
throw new IllegalArgumentException(" getN3EditOptionList requires parameter 'field'");
}
HttpSession sess = req.getSession(false);
EditConfiguration editConfig = EditConfiguration.getConfigFromSession(sess, req);
if( editConfig == null ) {
log.debug("could not find query parameter 'editKey' for doN3EditOptionList");
throw new IllegalArgumentException(" getN3EditOptionList requires parameter 'editKey'");
}
if( log.isDebugEnabled() )
log.debug(" attempting to get option list for field '" + field + "'");
// set ProhibitedFromSearch object so picklist doesn't show
// individuals from classes that should be hidden from list views
OntModel displayOntModel =
(OntModel) getServletConfig().getServletContext().getAttribute(DISPLAY_ONT_MODEL);
if (displayOntModel != null) {
ProhibitedFromSearch pfs = new ProhibitedFromSearch(
DisplayVocabulary.SEARCH_INDEX_URI, displayOntModel);
editConfig.setProhibitedFromSearch(pfs);
}
Map<String,String> options = SelectListGenerator.getOptions(editConfig, field, (new VitroRequest(req)).getFullWebappDaoFactory());
resp.setCharacterEncoding("UTF-8");
resp.setContentType("application/json;charset=UTF-8");
ServletOutputStream out = resp.getOutputStream();
out.println("[");
for(String key : options.keySet()){
JSONArray jsonObj = new JSONArray();
jsonObj.put( options.get(key));
jsonObj.put( key);
out.println(" " + jsonObj.toString() + ",");
}
out.println("]");
}
private void getEntitiesByVClassContinuation(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
log.debug("in getEntitiesByVClassContinuation()");
VitroRequest vreq = new VitroRequest(req);
String resKey = vreq.getParameter("resultKey");
if( resKey == null )
throw new ServletException("Could not get resultKey");
HttpSession session = vreq.getSession();
if( session == null )
throw new ServletException("there is no session to get the pervious results from");
@SuppressWarnings("unchecked")
List<Individual> entsInVClass = (List<Individual>) session.getAttribute(resKey);
if( entsInVClass == null )
throw new ServletException("Could not find List<Individual> for resultKey " + resKey);
List<Individual> entsToReturn = new ArrayList<Individual>(REPLY_SIZE);
boolean more = false;
int count = 0;
/* we have a large number of items to send back so we need to stash the list in the session scope */
if( entsInVClass.size() > REPLY_SIZE){
more = true;
ListIterator<Individual> entsFromVclass = entsInVClass.listIterator();
while ( entsFromVclass.hasNext() && count <= REPLY_SIZE ){
entsToReturn.add( entsFromVclass.next());
entsFromVclass.remove();
count++;
}
if( log.isDebugEnabled() ) log.debug("getEntitiesByVClassContinuation(): Creating reply with continue token," +
" sending in this reply: " + count +", remaing to send: " + entsInVClass.size() );
} else {
//send out reply with no continuation
entsToReturn = entsInVClass;
count = entsToReturn.size();
session.removeAttribute(resKey);
if( log.isDebugEnabled()) log.debug("getEntitiesByVClassContinuation(): sending " + count + " Ind without continue token");
}
//put all the entities on the JSON array
JSONArray ja = individualsToJson( entsToReturn );
//put the responseGroup number on the end of the JSON array
if( more ){
try{
JSONObject obj = new JSONObject();
obj.put("resultGroup", "true");
obj.put("size", count);
StringBuffer nextUrlStr = req.getRequestURL();
nextUrlStr.append("?")
.append("getEntitiesByVClass").append( "=1&" )
.append("resultKey=").append( resKey );
obj.put("nextUrl", nextUrlStr.toString());
ja.put(obj);
}catch(JSONException je ){
throw new ServletException(je.getMessage());
}
}
resp.setCharacterEncoding("UTF-8");
resp.setContentType("application/json;charset=UTF-8");
ServletOutputStream out = resp.getOutputStream();
out.print( ja.toString() );
log.debug("done with getEntitiesByVClassContinuation()");
}
/**
* Gets a list of entities that are members of the indicated vClass.
*
* If the list is large then we will pass some token indicating that there is more
* to come. The results are sent back in 250 entity blocks. To get all of the
* entities for a VClass just keep requesting lists until there are not more
* continue tokens.
*
* If there are more entities the last item on the returned array will be an object
* with no id property. It will look like this:
*
* {"resultGroup":0,
* "resultKey":"2WEK2306",
* "nextUrl":"http://caruso.mannlib.cornell.edu:8080/vitro/dataservice?getEntitiesByVClass=1&resultKey=2WEK2306&resultGroup=1&vclassId=null",
* "entsInVClass":1752,
* "nextResultGroup":1,
* "standardReplySize":256}
*
*/
private void getEntitiesByVClass(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException{
log.debug("in getEntitiesByVClass()");
VitroRequest vreq = new VitroRequest(req);
String vclassURI = vreq.getParameter("vclassURI");
WebappDaoFactory daos = (new VitroRequest(req)).getFullWebappDaoFactory();
resp.setCharacterEncoding("UTF-8");
PrintWriter out = resp.getWriter();
resp.getWriter();
if( vclassURI == null ){
log.debug("getEntitiesByVClass(): no value for 'vclassURI' found in the HTTP request");
out.print( (new JSONArray()).toString() ); return;
}
VClass vclass = daos.getVClassDao().getVClassByURI( vclassURI );
if( vclass == null ){
log.debug("getEntitiesByVClass(): could not find vclass for uri '"+ vclassURI + "'");
out.print( (new JSONArray()).toString() ); return;
}
List<Individual> entsInVClass = daos.getIndividualDao().getIndividualsByVClass( vclass );
if( entsInVClass == null ){
log.debug("getEntitiesByVClass(): null List<Individual> retruned by getIndividualsByVClass() for "+vclassURI);
out.print( (new JSONArray().toString() )); return ;
}
int numberOfEntsInVClass = entsInVClass.size();
List<Individual> entsToReturn = new ArrayList<Individual>( REPLY_SIZE );
String requestHash = null;
int count = 0;
boolean more = false;
/* we have a large number of items to send back so we need to stash the list in the session scope */
if( entsInVClass.size() > REPLY_SIZE){
more = true;
HttpSession session = vreq.getSession(true);
requestHash = Integer.toString((vclassURI + System.currentTimeMillis()).hashCode());
session.setAttribute(requestHash, entsInVClass );
ListIterator<Individual> entsFromVclass = entsInVClass.listIterator();
while ( entsFromVclass.hasNext() && count < REPLY_SIZE ){
entsToReturn.add( entsFromVclass.next());
entsFromVclass.remove();
count++;
}
if( log.isDebugEnabled() ){ log.debug("getEntitiesByVClass(): Creating reply with continue token, found " + numberOfEntsInVClass + " Individuals"); }
}else{
if( log.isDebugEnabled() ) log.debug("getEntitiesByVClass(): sending " + numberOfEntsInVClass +" Individuals without continue token");
entsToReturn = entsInVClass;
count = entsToReturn.size();
}
//put all the entities on the JSON array
JSONArray ja = individualsToJson( entsToReturn );
//put the responseGroup number on the end of the JSON array
if( more ){
try{
JSONObject obj = new JSONObject();
obj.put("resultGroup", "true");
obj.put("size", count);
obj.put("total", numberOfEntsInVClass);
StringBuffer nextUrlStr = req.getRequestURL();
nextUrlStr.append("?")
.append("getEntitiesByVClass").append( "=1&" )
.append("resultKey=").append( requestHash );
obj.put("nextUrl", nextUrlStr.toString());
ja.put(obj);
}catch(JSONException je ){
throw new ServletException("unable to create continuation as JSON: " + je.getMessage());
}
}
resp.setContentType("application/json;charset=UTF-8");
out.print( ja.toString() );
log.debug("done with getEntitiesByVClass()");
}
/**
* Gets data based on data getter for page uri and returns in the form of Json objects
* @param req
* @param resp
*/
private void getDataForPage(HttpServletRequest req, HttpServletResponse resp)
throws Exception{
VitroRequest vreq = new VitroRequest(req);
String errorMessage = null;
JSONObject rObj = null;
String pageUri = vreq.getParameter("pageUri");
if(pageUri != null && !pageUri.isEmpty()) {
ServletContext context = getServletContext();
Map<String,Object> data = PageDataGetterUtils.getDataForPage(pageUri, vreq, context);
//Convert to json version based on type of page
if(data != null) {
//Convert to json version based on type of page
rObj = PageDataGetterUtils.covertDataToJSONForPage(pageUri, data, vreq, context);
}
}
if( rObj == null )
rObj = new JSONObject();
//Send object
try{
resp.setCharacterEncoding("UTF-8");
resp.setContentType("application/json;charset=UTF-8");
if( errorMessage != null ){
rObj.put("errorMessage", errorMessage);
resp.setStatus(500 /*HttpURLConnection.HTTP_SERVER_ERROR*/);
}else{
rObj.put("errorMessage", "");
}
Writer writer = resp.getWriter();
writer.write(rObj.toString());
}catch(JSONException jse){
log.error(jse,jse);
} catch (IOException e) {
log.error(e,e);
}
}
private JSONArray individualsToJson(List<Individual> individuals) throws ServletException {
JSONArray ja = new JSONArray();
Iterator<Individual> it = individuals.iterator();
try{
while(it.hasNext()){
Individual ent = (Individual) it.next();
JSONObject entJ = new JSONObject();
entJ.put("name", ent.getName());
entJ.put("URI", ent.getURI());
ja.put( entJ );
}
}catch(JSONException ex){
throw new ServletException("could not convert list of Individuals into JSON: " + ex);
}
return ja;
}
}

20
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/ajax/VitroAjaxController.java
View file

@ -6,7 +6,6 @@ import java.io.IOException;
import java.io.PrintWriter; import java.io.PrintWriter;
import java.util.Map; import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.ServletException; import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
@ -70,22 +69,14 @@ public abstract class VitroAjaxController extends HttpServlet {
return Actions.AUTHORIZED; return Actions.AUTHORIZED;
} }
/**
* Returns the current Freemarker Configuration so the controller can process
* its data through a template.
*/
protected final Configuration getFreemarkerConfiguration(VitroRequest vreq) {
return FreemarkerConfigurationLoader.getConfig(vreq, getServletContext());
}
/** /**
* Process data through a Freemarker template and output the result. * Process data through a Freemarker template and output the result.
*/ */
protected void writeTemplate(String templateName, Map<String, Object> map, protected void writeTemplate(String templateName, Map<String, Object> map,
Configuration config, HttpServletRequest request, HttpServletResponse response) { VitroRequest vreq, HttpServletResponse response) {
Template template = null; Configuration config = FreemarkerConfigurationLoader.getConfig(vreq);
try { try {
template = config.getTemplate(templateName); Template template = config.getTemplate(templateName);
PrintWriter out = response.getWriter(); PrintWriter out = response.getWriter();
template.process(map, out); template.process(map, out);
} catch (Exception e) { } catch (Exception e) {
@ -93,12 +84,13 @@ public abstract class VitroAjaxController extends HttpServlet {
} }
} }
protected void doError(HttpServletResponse response, String errorMsg, int httpstatus){ protected void doError(HttpServletResponse response, String errorMsg,
int httpstatus) {
response.setStatus(httpstatus); response.setStatus(httpstatus);
try { try {
response.getWriter().write(errorMsg); response.getWriter().write(errorMsg);
} catch (IOException e) { } catch (IOException e) {
log.debug("IO exception during output",e ); log.debug("IO exception during output", e);
} }
} }
} }

2
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/BaseSiteAdminController.java
View file

@ -130,10 +130,12 @@ public class BaseSiteAdminController extends FreemarkerHttpServlet {
data.put("siteInfo", UrlBuilder.getUrl("/editForm", "controller", "ApplicationBean")); data.put("siteInfo", UrlBuilder.getUrl("/editForm", "controller", "ApplicationBean"));
} }
//TODO: Add specific permissions for page management
if (PolicyHelper.isAuthorizedForActions(vreq, SimplePermission.MANAGE_MENUS.ACTIONS)) { if (PolicyHelper.isAuthorizedForActions(vreq, SimplePermission.MANAGE_MENUS.ACTIONS)) {
data.put("menuManagement", UrlBuilder.getUrl("/individual", data.put("menuManagement", UrlBuilder.getUrl("/individual",
"uri", "http://vitro.mannlib.cornell.edu/ontologies/display/1.1#DefaultMenu", "uri", "http://vitro.mannlib.cornell.edu/ontologies/display/1.1#DefaultMenu",
"switchToDisplayModel", "true")); "switchToDisplayModel", "true"));
data.put("pageManagement", UrlBuilder.getUrl("/pageList"));
} }
if (PolicyHelper.isAuthorizedForActions(vreq, SimplePermission.SEE_STARTUP_STATUS.ACTIONS)) { if (PolicyHelper.isAuthorizedForActions(vreq, SimplePermission.SEE_STARTUP_STATUS.ACTIONS)) {

14
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/ContactMailController.java
View file

@ -32,7 +32,6 @@ import edu.cornell.mannlib.vitro.webapp.controller.freemarker.TemplateProcessing
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.ResponseValues; import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.ResponseValues;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.TemplateResponseValues; import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.TemplateResponseValues;
import edu.cornell.mannlib.vitro.webapp.email.FreemarkerEmailFactory; import edu.cornell.mannlib.vitro.webapp.email.FreemarkerEmailFactory;
import freemarker.template.Configuration;
public class ContactMailController extends FreemarkerHttpServlet { public class ContactMailController extends FreemarkerHttpServlet {
private static final Log log = LogFactory private static final Log log = LogFactory
@ -112,15 +111,14 @@ public class ContactMailController extends FreemarkerHttpServlet {
String originalReferer = getOriginalRefererFromSession(vreq); String originalReferer = getOriginalRefererFromSession(vreq);
Configuration config = (Configuration) vreq.getAttribute("freemarkerConfig");
String msgText = composeEmail(webusername, webuseremail, comments, String msgText = composeEmail(webusername, webuseremail, comments,
deliveryfrom, originalReferer, vreq.getRemoteAddr(), config, vreq); deliveryfrom, originalReferer, vreq.getRemoteAddr(), vreq);
try { try {
// Write the message to the journal file // Write the message to the journal file
FileWriter fw = new FileWriter(locateTheJournalFile(vreq),true); FileWriter fw = new FileWriter(locateTheJournalFile(vreq),true);
PrintWriter outFile = new PrintWriter(fw); PrintWriter outFile = new PrintWriter(fw);
writeBackupCopy(outFile, msgText, config, vreq); writeBackupCopy(outFile, msgText, vreq);
try { try {
// Send the message // Send the message
@ -222,7 +220,7 @@ public class ContactMailController extends FreemarkerHttpServlet {
private String composeEmail(String webusername, String webuseremail, private String composeEmail(String webusername, String webuseremail,
String comments, String deliveryfrom, String comments, String deliveryfrom,
String originalReferer, String ipAddr, Configuration config, String originalReferer, String ipAddr,
HttpServletRequest request) { HttpServletRequest request) {
Map<String, Object> email = new HashMap<String, Object>(); Map<String, Object> email = new HashMap<String, Object>();
@ -238,7 +236,7 @@ public class ContactMailController extends FreemarkerHttpServlet {
} }
try { try {
return processTemplateToString(template, email, config, request); return processTemplateToString(template, email, request);
} catch (TemplateProcessingException e) { } catch (TemplateProcessingException e) {
log.error("Error processing email text through template: " + e.getMessage(), e); log.error("Error processing email text through template: " + e.getMessage(), e);
return null; return null;
@ -246,7 +244,7 @@ public class ContactMailController extends FreemarkerHttpServlet {
} }
private void writeBackupCopy(PrintWriter outFile, String msgText, private void writeBackupCopy(PrintWriter outFile, String msgText,
Configuration config, HttpServletRequest request) { HttpServletRequest request) {
Map<String, Object> backup = new HashMap<String, Object>(); Map<String, Object> backup = new HashMap<String, Object>();
String template = TEMPLATE_BACKUP; String template = TEMPLATE_BACKUP;
@ -256,7 +254,7 @@ public class ContactMailController extends FreemarkerHttpServlet {
backup.put("msgText", msgText); backup.put("msgText", msgText);
try { try {
String backupText = processTemplateToString(template, backup, config, request); String backupText = processTemplateToString(template, backup, request);
outFile.print(backupText); outFile.print(backupText);
outFile.flush(); outFile.flush();
//outFile.close(); //outFile.close();

24
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/FreemarkerComponentGenerator.java
View file

@ -2,7 +2,6 @@
package edu.cornell.mannlib.vitro.webapp.controller.freemarker; package edu.cornell.mannlib.vitro.webapp.controller.freemarker;
import java.util.HashMap;
import java.util.Map; import java.util.Map;
import javax.servlet.ServletContext; import javax.servlet.ServletContext;
@ -14,7 +13,6 @@ import org.apache.commons.logging.LogFactory;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest; import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.TemplateProcessingHelper.TemplateProcessingException; import edu.cornell.mannlib.vitro.webapp.controller.freemarker.TemplateProcessingHelper.TemplateProcessingException;
import freemarker.template.Configuration;
/** /**
* TEMPORARY for transition from JSP to FreeMarker. Once transition * TEMPORARY for transition from JSP to FreeMarker. Once transition
@ -34,35 +32,33 @@ public class FreemarkerComponentGenerator extends FreemarkerHttpServlet {
// Mimic what FreemarkerHttpServlet does for a new request // Mimic what FreemarkerHttpServlet does for a new request
VitroRequest vreq = new VitroRequest(request); VitroRequest vreq = new VitroRequest(request);
FreemarkerConfiguration config = getConfig(vreq);
vreq.setAttribute("freemarkerConfig", config);
Map<String, Object> map = getPageTemplateValues(vreq); Map<String, Object> map = getPageTemplateValues(vreq);
request.setAttribute("ftl_head", getHead("head", map, config, vreq)); request.setAttribute("ftl_head", getHead("head", map, vreq));
request.setAttribute("ftl_identity", get("identity", map, config, vreq)); request.setAttribute("ftl_identity", get("identity", map, vreq));
request.setAttribute("ftl_menu", get("menu", map, config, vreq)); request.setAttribute("ftl_menu", get("menu", map, vreq));
request.setAttribute("ftl_search", get("search", map, config, vreq)); request.setAttribute("ftl_search", get("search", map, vreq));
request.setAttribute("ftl_footer", get("footer", map, config, vreq)); request.setAttribute("ftl_footer", get("footer", map, vreq));
request.setAttribute("ftl_googleAnalytics", get("googleAnalytics", map, config, vreq)); request.setAttribute("ftl_googleAnalytics", get("googleAnalytics", map, vreq));
} }
private String get(String templateName, Map<String, Object> root, Configuration config, HttpServletRequest request) { private String get(String templateName, Map<String, Object> root, HttpServletRequest request) {
templateName += ".ftl"; templateName += ".ftl";
try { try {
return processTemplate(templateName, root, config, request).toString(); return processTemplate(templateName, root, request).toString();
} catch (TemplateProcessingException e) { } catch (TemplateProcessingException e) {
log.error("Error processing template " + templateName + ": " + e.getMessage(), e); log.error("Error processing template " + templateName + ": " + e.getMessage(), e);
return null; return null;
} }
} }
private String getHead(String templateName, Map<String, Object> root, Configuration config, HttpServletRequest request) { private String getHead(String templateName, Map<String, Object> root, HttpServletRequest request) {
// The Freemarker head template displays the page title in the <title> tag. Get the value out of the request. // The Freemarker head template displays the page title in the <title> tag. Get the value out of the request.
String title = (String) request.getAttribute("title"); String title = (String) request.getAttribute("title");
if (!StringUtils.isEmpty(title)) { if (!StringUtils.isEmpty(title)) {
root.put("title", title); root.put("title", title);
} }
return get(templateName, root, config, request); return get(templateName, root, request);
} }
// RY We need the servlet context in getConfig(). For some reason using the method inherited from // RY We need the servlet context in getConfig(). For some reason using the method inherited from

16
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/FreemarkerConfiguration.java
View file

@ -17,9 +17,9 @@ import org.apache.commons.logging.LogFactory;
import edu.cornell.mannlib.vitro.webapp.beans.ApplicationBean; import edu.cornell.mannlib.vitro.webapp.beans.ApplicationBean;
import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties; import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties;
import edu.cornell.mannlib.vitro.webapp.config.RevisionInfoBean; import edu.cornell.mannlib.vitro.webapp.config.RevisionInfoBean;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.UrlBuilder.Route; import edu.cornell.mannlib.vitro.webapp.controller.freemarker.UrlBuilder.Route;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.EditConfigurationConstants; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.EditConfigurationConstants;
import edu.cornell.mannlib.vitro.webapp.web.directives.IndividualShortViewDirective;
import edu.cornell.mannlib.vitro.webapp.web.methods.IndividualLocalNameMethod; import edu.cornell.mannlib.vitro.webapp.web.methods.IndividualLocalNameMethod;
import edu.cornell.mannlib.vitro.webapp.web.methods.IndividualPlaceholderImageUrlMethod; import edu.cornell.mannlib.vitro.webapp.web.methods.IndividualPlaceholderImageUrlMethod;
import edu.cornell.mannlib.vitro.webapp.web.methods.IndividualProfileUrlMethod; import edu.cornell.mannlib.vitro.webapp.web.methods.IndividualProfileUrlMethod;
@ -40,14 +40,12 @@ public class FreemarkerConfiguration extends Configuration {
private final String themeDir; private final String themeDir;
private final ServletContext context; private final ServletContext context;
private final ApplicationBean appBean; private final ApplicationBean appBean;
private final String appName;
FreemarkerConfiguration(String themeDir, VitroRequest vreq, ServletContext context) { FreemarkerConfiguration(String themeDir, ApplicationBean appBean, ServletContext context) {
this.themeDir = themeDir; this.themeDir = themeDir;
this.context = context; this.context = context;
this.appBean = vreq.getAppBean(); this.appBean = appBean;
this.appName = appBean.getApplicationName();
String buildEnv = ConfigurationProperties.getBean(context).getProperty("Environment.build"); String buildEnv = ConfigurationProperties.getBean(context).getProperty("Environment.build");
log.debug("Current build environment: " + buildEnv); log.debug("Current build environment: " + buildEnv);
@ -88,7 +86,7 @@ public class FreemarkerConfiguration extends Configuration {
setTemplateLoader(createTemplateLoader()); setTemplateLoader(createTemplateLoader());
setSharedVariables(vreq); setSharedVariables();
} }
@ -96,13 +94,12 @@ public class FreemarkerConfiguration extends Configuration {
* These are values that are accessible to all * These are values that are accessible to all
* templates loaded by the Configuration's TemplateLoader. They * templates loaded by the Configuration's TemplateLoader. They
* should be application- rather than request-specific. * should be application- rather than request-specific.
* @param VitroRequest vreq
*/ */
private void setSharedVariables(VitroRequest vreq) { private void setSharedVariables() {
Map<String, Object> sharedVariables = new HashMap<String, Object>(); Map<String, Object> sharedVariables = new HashMap<String, Object>();
sharedVariables.put("siteName", appName); sharedVariables.put("siteName", appBean.getApplicationName());
sharedVariables.put("version", getRevisionInfo()); sharedVariables.put("version", getRevisionInfo());
sharedVariables.put("urls", getSiteUrls()); sharedVariables.put("urls", getSiteUrls());
sharedVariables.put("themeDir", themeDir); sharedVariables.put("themeDir", themeDir);
@ -158,6 +155,7 @@ public class FreemarkerConfiguration extends Configuration {
map.put("dump", new freemarker.ext.dump.DumpDirective()); map.put("dump", new freemarker.ext.dump.DumpDirective());
map.put("dumpAll", new freemarker.ext.dump.DumpAllDirective()); map.put("dumpAll", new freemarker.ext.dump.DumpAllDirective());
map.put("help", new freemarker.ext.dump.HelpDirective()); map.put("help", new freemarker.ext.dump.HelpDirective());
map.put("shortView", new IndividualShortViewDirective());
return map; return map;
} }

11
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/FreemarkerConfigurationLoader.java
View file

@ -19,10 +19,9 @@ public class FreemarkerConfigurationLoader {
private static final Map<String, FreemarkerConfiguration> themeToConfigMap = new HashMap<String, FreemarkerConfiguration>(); private static final Map<String, FreemarkerConfiguration> themeToConfigMap = new HashMap<String, FreemarkerConfiguration>();
public static FreemarkerConfiguration getConfig(VitroRequest vreq, public static FreemarkerConfiguration getConfig(VitroRequest vreq) {
ServletContext context) {
String themeDir = getThemeDir(vreq.getAppBean()); String themeDir = getThemeDir(vreq.getAppBean());
return getConfigForTheme(themeDir, vreq, context); return getConfigForTheme(themeDir, vreq.getAppBean(), vreq.getSession().getServletContext());
} }
private static String getThemeDir(ApplicationBean appBean) { private static String getThemeDir(ApplicationBean appBean) {
@ -46,16 +45,16 @@ public class FreemarkerConfigurationLoader {
* 1. The template loader is theme-specific, since it specifies a theme * 1. The template loader is theme-specific, since it specifies a theme
* directory to load templates from. * directory to load templates from.
* *
* 2. Shared variables like stylesheets are theme-specific. * 2. Some shared variables are theme-specific.
*/ */
private static FreemarkerConfiguration getConfigForTheme(String themeDir, private static FreemarkerConfiguration getConfigForTheme(String themeDir,
VitroRequest vreq, ServletContext context) { ApplicationBean appBean, ServletContext context) {
synchronized (themeToConfigMap) { synchronized (themeToConfigMap) {
if (themeToConfigMap.containsKey(themeDir)) { if (themeToConfigMap.containsKey(themeDir)) {
return themeToConfigMap.get(themeDir); return themeToConfigMap.get(themeDir);
} else { } else {
FreemarkerConfiguration config = new FreemarkerConfiguration( FreemarkerConfiguration config = new FreemarkerConfiguration(
themeDir, vreq, context); themeDir, appBean, context);
themeToConfigMap.put(themeDir, config); themeToConfigMap.put(themeDir, config);
return config; return config;
} }

46
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/FreemarkerHttpServlet.java
View file

@ -41,7 +41,6 @@ import edu.cornell.mannlib.vitro.webapp.web.templatemodels.Tags;
import edu.cornell.mannlib.vitro.webapp.web.templatemodels.User; import edu.cornell.mannlib.vitro.webapp.web.templatemodels.User;
import edu.cornell.mannlib.vitro.webapp.web.templatemodels.menu.MainMenu; import edu.cornell.mannlib.vitro.webapp.web.templatemodels.menu.MainMenu;
import freemarker.ext.beans.BeansWrapper; import freemarker.ext.beans.BeansWrapper;
import freemarker.template.Configuration;
import freemarker.template.DefaultObjectWrapper; import freemarker.template.DefaultObjectWrapper;
import freemarker.template.TemplateModel; import freemarker.template.TemplateModel;
import freemarker.template.TemplateModelException; import freemarker.template.TemplateModelException;
@ -100,9 +99,6 @@ public class FreemarkerHttpServlet extends VitroHttpServlet {
return; return;
} }
FreemarkerConfiguration config = getConfig(vreq);
vreq.setAttribute("freemarkerConfig", config);
responseValues = processRequest(vreq); responseValues = processRequest(vreq);
doResponse(vreq, response, responseValues); doResponse(vreq, response, responseValues);
@ -196,10 +192,6 @@ public class FreemarkerHttpServlet extends VitroHttpServlet {
doGet(request, response); doGet(request, response);
} }
protected FreemarkerConfiguration getConfig(VitroRequest vreq) {
return FreemarkerConfigurationLoader.getConfig(vreq, getServletContext());
}
/** /**
* By default, a page requires authorization for no actions. * By default, a page requires authorization for no actions.
* Subclasses that require authorization to process their page will override * Subclasses that require authorization to process their page will override
@ -249,8 +241,6 @@ public class FreemarkerHttpServlet extends VitroHttpServlet {
protected void doTemplate(VitroRequest vreq, HttpServletResponse response, protected void doTemplate(VitroRequest vreq, HttpServletResponse response,
ResponseValues values) throws TemplateProcessingException { ResponseValues values) throws TemplateProcessingException {
Configuration config = getConfig(vreq);
Map<String, Object> templateDataModel = new HashMap<String, Object>(); Map<String, Object> templateDataModel = new HashMap<String, Object>();
templateDataModel.putAll(getPageTemplateValues(vreq)); templateDataModel.putAll(getPageTemplateValues(vreq));
@ -265,7 +255,7 @@ public class FreemarkerHttpServlet extends VitroHttpServlet {
if (bodyTemplate != null) { if (bodyTemplate != null) {
// Tell the template and any directives it uses that we're processing a body template. // Tell the template and any directives it uses that we're processing a body template.
templateDataModel.put("templateType", BODY_TEMPLATE_TYPE); templateDataModel.put("templateType", BODY_TEMPLATE_TYPE);
bodyString = processTemplateToString(bodyTemplate, templateDataModel, config, vreq); bodyString = processTemplateToString(bodyTemplate, templateDataModel, vreq);
} else { } else {
// The subcontroller has not defined a body template. All markup for the page // The subcontroller has not defined a body template. All markup for the page
// is specified in the main page template. // is specified in the main page template.
@ -276,7 +266,7 @@ public class FreemarkerHttpServlet extends VitroHttpServlet {
// Tell the template and any directives it uses that we're processing a page template. // Tell the template and any directives it uses that we're processing a page template.
templateDataModel.put("templateType", PAGE_TEMPLATE_TYPE); templateDataModel.put("templateType", PAGE_TEMPLATE_TYPE);
writePage(templateDataModel, config, vreq, response, values.getStatusCode(), values); writePage(templateDataModel, vreq, response, values.getStatusCode(), values);
} }
protected void doRedirect(HttpServletRequest request, HttpServletResponse response, ResponseValues values) protected void doRedirect(HttpServletRequest request, HttpServletResponse response, ResponseValues values)
@ -346,7 +336,7 @@ public class FreemarkerHttpServlet extends VitroHttpServlet {
private Map<String, Object> buildRequestUrls(VitroRequest vreq) { private Map<String, Object> buildRequestUrls(VitroRequest vreq) {
Map<String, Object> requestUrls = new HashMap<String, Object>(); Map<String, Object> requestUrls = new HashMap<String, Object>();
FreemarkerConfiguration config = (FreemarkerConfiguration)vreq.getAttribute("freemarkerConfig"); FreemarkerConfiguration config = FreemarkerConfigurationLoader.getConfig(vreq);
TemplateModel urlModel = config.getSharedVariable("urls"); TemplateModel urlModel = config.getSharedVariable("urls");
try { try {
@ -485,29 +475,19 @@ public class FreemarkerHttpServlet extends VitroHttpServlet {
return siteName; return siteName;
} }
protected StringWriter processTemplate(String templateName, Map<String, Object> map, Configuration config, protected StringWriter processTemplate(String templateName, Map<String, Object> map,
HttpServletRequest request) throws TemplateProcessingException { HttpServletRequest request) throws TemplateProcessingException {
TemplateProcessingHelper helper = new TemplateProcessingHelper(config, request, getServletContext()); TemplateProcessingHelper helper = new TemplateProcessingHelper(request, getServletContext());
return helper.processTemplate(templateName, map); return helper.processTemplate(templateName, map);
} }
protected StringWriter processTemplate(ResponseValues values, Configuration config,
HttpServletRequest request) throws TemplateProcessingException {
return processTemplate(values.getTemplateName(), values.getMap(), config, request);
}
// In fact, we can put StringWriter objects directly into the data model, so perhaps we should eliminate the processTemplateToString() methods. // In fact, we can put StringWriter objects directly into the data model, so perhaps we should eliminate the processTemplateToString() methods.
protected String processTemplateToString(String templateName, Map<String, Object> map, Configuration config, protected String processTemplateToString(String templateName, Map<String, Object> map,
HttpServletRequest request) throws TemplateProcessingException { HttpServletRequest request) throws TemplateProcessingException {
return processTemplate(templateName, map, config, request).toString(); return processTemplate(templateName, map, request).toString();
} }
protected String processTemplateToString(ResponseValues values, Configuration config, protected void writePage(Map<String, Object> root, HttpServletRequest request,
HttpServletRequest request) throws TemplateProcessingException {
return processTemplate(values, config, request).toString();
}
protected void writePage(Map<String, Object> root, Configuration config, HttpServletRequest request,
HttpServletResponse response, int statusCode, ResponseValues rv) throws TemplateProcessingException { HttpServletResponse response, int statusCode, ResponseValues rv) throws TemplateProcessingException {
// For an error page, use the standard page template rather than a special one, in case that is the source // For an error page, use the standard page template rather than a special one, in case that is the source
@ -515,17 +495,17 @@ public class FreemarkerHttpServlet extends VitroHttpServlet {
// less likely. // less likely.
String pageTemplateName = String pageTemplateName =
rv instanceof ExceptionResponseValues ? Template.PAGE_DEFAULT.toString() : getPageTemplateName(); rv instanceof ExceptionResponseValues ? Template.PAGE_DEFAULT.toString() : getPageTemplateName();
writeTemplate(pageTemplateName, root, config, request, response, statusCode); writeTemplate(pageTemplateName, root, request, response, statusCode);
} }
protected void writeTemplate(String templateName, Map<String, Object> map, Configuration config, protected void writeTemplate(String templateName, Map<String, Object> map,
HttpServletRequest request, HttpServletResponse response) throws TemplateProcessingException { HttpServletRequest request, HttpServletResponse response) throws TemplateProcessingException {
writeTemplate(templateName, map, config, request, response, 0); writeTemplate(templateName, map, request, response, 0);
} }
protected void writeTemplate(String templateName, Map<String, Object> map, Configuration config, protected void writeTemplate(String templateName, Map<String, Object> map,
HttpServletRequest request, HttpServletResponse response, int statusCode) throws TemplateProcessingException { HttpServletRequest request, HttpServletResponse response, int statusCode) throws TemplateProcessingException {
StringWriter sw = processTemplate(templateName, map, config, request); StringWriter sw = processTemplate(templateName, map, request);
write(sw, response, statusCode); write(sw, response, statusCode);
} }

4
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/HomePageController.java
View file

@ -28,10 +28,10 @@ public class HomePageController extends FreemarkerHttpServlet {
Map<String, Object> body = new HashMap<String, Object>(); Map<String, Object> body = new HashMap<String, Object>();
List<DataGetter> dgList = DataGetterUtils.getDataGettersForPage(vreq.getDisplayModel(), DisplayVocabulary.HOME_PAGE_URI); List<DataGetter> dgList = DataGetterUtils.getDataGettersForPage(vreq, vreq.getDisplayModel(), DisplayVocabulary.HOME_PAGE_URI);
for( DataGetter dg : dgList){ for( DataGetter dg : dgList){
Map<String,Object> moreData = dg.getData(getServletContext(),vreq,body); Map<String,Object> moreData = dg.getData(body);
if( moreData != null ){ if( moreData != null ){
body.putAll(moreData); body.putAll(moreData);
} }

121
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/IndividualListController.java
View file

@ -2,25 +2,21 @@
package edu.cornell.mannlib.vitro.webapp.controller.freemarker; package edu.cornell.mannlib.vitro.webapp.controller.freemarker;
import java.io.IOException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.Iterator;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import javax.servlet.ServletContext; import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import org.apache.commons.lang.StringUtils; import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.apache.solr.client.solrj.SolrQuery; import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServer; import org.apache.solr.client.solrj.SolrServer;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.response.QueryResponse; import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import edu.cornell.mannlib.vitro.webapp.beans.Individual; import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.beans.VClass; import edu.cornell.mannlib.vitro.webapp.beans.VClass;
@ -165,36 +161,14 @@ public class IndividualListController extends FreemarkerHttpServlet {
} }
} }
// //Pulling out common code that is used for both single (regular) vclass query and multiple (intersection) query
// public static Map<String,Object> getResultsForVClasses(List<String> vclassURIs, int page, String alpha, IndividualDao indDao, ServletContext context)
// throws IOException, ServletException{
// Map<String,Object> rvMap = new HashMap<String,Object>();
// try{
// SolrQuery query = getQuery(vclassURIs, alpha, page, INDIVIDUALS_PER_PAGE);
// rvMap = getResultsForVClassQuery(query, page, alpha, indDao, context);
// List<Individual> individuals = (List<Individual>) rvMap.get("entities");
// if (individuals == null)
// log.debug("entities list is null for vclasses " + vclassURIs.toString() );
// } catch(Throwable th) {
// log.error("An error occurred retrieving results for vclass query", th);
// }
// return rvMap;
// }
@SuppressWarnings("unchecked")
public static Map<String,Object> getResultsForVClass(String vclassURI, int page, String alpha, IndividualDao indDao, ServletContext context) public static Map<String,Object> getResultsForVClass(String vclassURI, int page, String alpha, IndividualDao indDao, ServletContext context)
throws IOException, SearchException{ throws SearchException{
Map<String,Object> rvMap = new HashMap<String,Object>(); Map<String,Object> rvMap = new HashMap<String,Object>();
try{ try{
//make query for this rdf:type List<String> classUris = Collections.singletonList(vclassURI);
List<String> classUris = new ArrayList<String>(); IndividualListQueryResults results = buildAndExecuteVClassQuery(classUris, alpha, page, INDIVIDUALS_PER_PAGE, context, indDao);
classUris.add(vclassURI); rvMap = getResultsForVClassQuery(results, page, INDIVIDUALS_PER_PAGE, alpha);
SolrQuery query = getQuery(classUris, alpha, page, INDIVIDUALS_PER_PAGE); } catch (SolrServerException e) {
rvMap = getResultsForVClassQuery(query, page, INDIVIDUALS_PER_PAGE, alpha, indDao, context);
List<Individual> individuals = (List<Individual>) rvMap.get("entities");
if (individuals == null)
log.debug("entities list is null for vclass " + vclassURI );
} catch (ServletException e) {
String msg = "An error occurred retrieving results for vclass query"; String msg = "An error occurred retrieving results for vclass query";
log.error(msg, e); log.error(msg, e);
// Throw this up to processRequest, so the template gets the error message. // Throw this up to processRequest, so the template gets the error message.
@ -205,72 +179,34 @@ public class IndividualListController extends FreemarkerHttpServlet {
return rvMap; return rvMap;
} }
@SuppressWarnings("unchecked") public static Map<String,Object> getResultsForVClassIntersections(List<String> vclassURIs, int page, int pageSize, String alpha, IndividualDao indDao, ServletContext context) {
public static Map<String,Object> getResultsForVClassIntersections(List<String> vclassURIs, int page, int pageSize, String alpha, IndividualDao indDao, ServletContext context)
throws IOException, ServletException{
Map<String,Object> rvMap = new HashMap<String,Object>(); Map<String,Object> rvMap = new HashMap<String,Object>();
try{ try{
// make query for multiple rdf types IndividualListQueryResults results = buildAndExecuteVClassQuery(vclassURIs, alpha, page, pageSize, context, indDao);
SolrQuery query = getQuery(vclassURIs, alpha, page, pageSize); rvMap = getResultsForVClassQuery(results, page, pageSize, alpha);
log.debug("Executed solr query for " + vclassURIs.toString());
rvMap = getResultsForVClassQuery(query, page, pageSize, alpha, indDao, context);
List<Individual> individuals = (List<Individual>) rvMap.get("entities");
if (individuals == null)
log.debug("entities list is null for vclass " + vclassURIs.toString() );
} catch(Throwable th) { } catch(Throwable th) {
log.error("Error retrieving individuals corresponding to intersection multiple classes." + vclassURIs.toString(), th); log.error("Error retrieving individuals corresponding to intersection multiple classes." + vclassURIs.toString(), th);
} }
return rvMap; return rvMap;
} }
/** private static IndividualListQueryResults buildAndExecuteVClassQuery(
* This method is now called in a couple of places. It should be refactored List<String> vclassURIs, String alpha, int page, int pageSize,
* into a DAO or similar object. ServletContext context, IndividualDao indDao)
*/ throws SolrServerException {
protected static Map<String,Object> getResultsForVClassQuery(SolrQuery query, int page, int pageSize, String alpha, IndividualDao indDao, ServletContext context) SolrQuery query = getQuery(vclassURIs, alpha, page, pageSize);
throws IOException, ServletException { IndividualListQueryResults results = IndividualListQueryResults.runQuery(query, indDao, context);
log.debug("Executed solr query for " + vclassURIs);
if (results.getIndividuals().isEmpty()) {
log.debug("entities list is null for vclass " + vclassURIs);
}
return results;
}
private static Map<String,Object> getResultsForVClassQuery(IndividualListQueryResults results, int page, int pageSize, String alpha) {
Map<String,Object> rvMap = new HashMap<String,Object>(); Map<String,Object> rvMap = new HashMap<String,Object>();
SolrServer solr = SolrSetup.getSolrServer(context);
QueryResponse response = null;
// Execute query for individuals of the specified type
try {
response = solr.query(query);
} catch (Throwable t) {
log.error(t, t);
}
if ( response == null ) {
throw new ServletException("Could not run search in IndividualListController");
}
SolrDocumentList docs = response.getResults();
if (docs == null) {
throw new ServletException("Could not run search in IndividualListController");
}
// get list of individuals for the search results
long hitCount = docs.getNumFound();
log.debug("Number of search results: " + hitCount);
Iterator<SolrDocument> docIter = docs.iterator();
List<Individual> individuals = new ArrayList<Individual>(docs.size());
while ( docIter.hasNext() ){
SolrDocument doc = docIter.next();
if (doc != null) {
String uri = doc.get(VitroSearchTermNames.URI).toString();
Individual individual = indDao.getIndividualByURI( uri );
if (individual != null) {
individuals.add( individual );
log.debug("Adding individual " + uri + " to individual list display");
} else {
log.debug("No existing individual for search document with uri = " + uri);
}
}
}
long hitCount = results.getHitCount();
if ( hitCount > pageSize ){ if ( hitCount > pageSize ){
rvMap.put("showPages", Boolean.TRUE); rvMap.put("showPages", Boolean.TRUE);
List<PageRecord> pageRecords = makePagesList(hitCount, pageSize, page); List<PageRecord> pageRecords = makePagesList(hitCount, pageSize, page);
@ -281,9 +217,8 @@ public class IndividualListController extends FreemarkerHttpServlet {
} }
rvMap.put("alpha",alpha); rvMap.put("alpha",alpha);
rvMap.put("totalCount", hitCount); rvMap.put("totalCount", hitCount);
rvMap.put("entities",individuals); rvMap.put("entities", results.getIndividuals());
return rvMap; return rvMap;
} }
@ -337,17 +272,13 @@ public class IndividualListController extends FreemarkerHttpServlet {
} }
private static String makeMultiClassQuery( List<String> vclassUris){ private static String makeMultiClassQuery( List<String> vclassUris){
String queryText = "";
List<String> queryTypes = new ArrayList<String>(); List<String> queryTypes = new ArrayList<String>();
try { try {
// query term for rdf:type - multiple types possible // query term for rdf:type - multiple types possible
for(String vclassUri: vclassUris) { for(String vclassUri: vclassUris) {
queryTypes.add(VitroSearchTermNames.RDFTYPE + ":\"" + vclassUri + "\" "); queryTypes.add(VitroSearchTermNames.RDFTYPE + ":\"" + vclassUri + "\" ");
} }
if (queryTypes.size() > 0) { return StringUtils.join(queryTypes, " AND ");
queryText = StringUtils.join(queryTypes, " AND ");
}
return queryText;
} catch (Exception ex){ } catch (Exception ex){
log.error("Could not make Solr query",ex); log.error("Could not make Solr query",ex);
return ""; return "";

98
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/IndividualListQueryResults.java Normal file
View file

@ -0,0 +1,98 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.freemarker;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.ServletContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServer;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.dao.IndividualDao;
import edu.cornell.mannlib.vitro.webapp.search.VitroSearchTermNames;
import edu.cornell.mannlib.vitro.webapp.search.solr.SolrSetup;
/**
* Holds the Individuals that were found in a Solr search query.
*
* Provides a convenience method to run the query and to find the Individuals.
*/
public class IndividualListQueryResults {
private static final Log log = LogFactory
.getLog(IndividualListQueryResults.class);
private static final IndividualListQueryResults EMPTY_RESULT = new IndividualListQueryResults(
0, new ArrayList<Individual>());
// ----------------------------------------------------------------------
// Convenience method
// ----------------------------------------------------------------------
public static IndividualListQueryResults runQuery(SolrQuery query,
IndividualDao indDao, ServletContext context)
throws SolrServerException {
SolrServer solr = SolrSetup.getSolrServer(context);
QueryResponse response = null;
response = solr.query(query);
if (response == null) {
log.debug("response from search query was null");
return EMPTY_RESULT;
}
SolrDocumentList docs = response.getResults();
if (docs == null) {
log.debug("results from search query response was null");
return EMPTY_RESULT;
}
// get list of individuals for the search results
long hitCount = docs.getNumFound();
log.debug("Number of search results: " + hitCount);
List<Individual> individuals = new ArrayList<Individual>(docs.size());
for (SolrDocument doc : docs) {
String uri = doc.get(VitroSearchTermNames.URI).toString();
Individual individual = indDao.getIndividualByURI(uri);
if (individual == null) {
log.debug("No individual for search document with uri = " + uri);
} else {
individuals.add(individual);
log.debug("Adding individual " + uri + " to individual list");
}
}
return new IndividualListQueryResults((int) hitCount, individuals);
}
// ----------------------------------------------------------------------
// The instance
// ----------------------------------------------------------------------
private final int hitCount;
private final List<Individual> individuals;
public IndividualListQueryResults(int hitCount, List<Individual> individuals) {
this.hitCount = hitCount;
this.individuals = individuals;
}
public int getHitCount() {
return hitCount;
}
public List<Individual> getIndividuals() {
return individuals;
}
}

117
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/ListClassGroupsController.java Normal file
View file

@ -0,0 +1,117 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.freemarker;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.List;
import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import edu.cornell.mannlib.vitro.webapp.auth.permissions.SimplePermission;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.Actions;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.beans.VClassGroup;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.ResponseValues;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.TemplateResponseValues;
import edu.cornell.mannlib.vitro.webapp.dao.VClassGroupDao;
public class ListClassGroupsController extends FreemarkerHttpServlet {
private static final Log log = LogFactory.getLog(ListClassGroupsController.class.getName());
private static final String TEMPLATE_NAME = "siteAdmin-classHierarchy.ftl";
@Override
protected Actions requiredActions(VitroRequest vreq) {
return SimplePermission.EDIT_ONTOLOGY.ACTIONS;
}
@Override
protected ResponseValues processRequest(VitroRequest vreq) {
Map<String, Object> body = new HashMap<String, Object>();
try {
body.put("displayOption", "group");
body.put("pageTitle", "Class Groups");
VClassGroupDao dao = vreq.getFullWebappDaoFactory().getVClassGroupDao();
List<VClassGroup> groups = dao.getPublicGroupsWithVClasses();
String json = new String();
int counter = 0;
if (groups != null) {
for(VClassGroup vcg: groups) {
if ( counter > 0 ) {
json += ", ";
}
String publicName = vcg.getPublicName();
if ( StringUtils.isBlank(publicName) ) {
publicName = "(unnamed group)";
}
try {
json += "{ \"name\": \"<a href='./editForm?uri="+URLEncoder.encode(vcg.getURI(),"UTF-8")+"&amp;controller=Classgroup'>"+publicName+"</a>\", ";
} catch (Exception e) {
json += "{ \"name\": \"" + publicName + "\", ";
}
Integer t;
json += "\"data\": { \"displayRank\": \"" + (((t = Integer.valueOf(vcg.getDisplayRank())) != -1) ? t.toString() : "") + "\"}, ";
List<VClass> classList = vcg.getVitroClassList();
if (classList != null && classList.size()>0) {
json += "\"children\": [";
Iterator<VClass> classIt = classList.iterator();
while (classIt.hasNext()) {
VClass vcw = classIt.next();
if (vcw.getName() != null && vcw.getURI() != null) {
try {
json += "{ \"name\": \"<a href='vclassEdit?uri="+URLEncoder.encode(vcw.getURI(),"UTF-8")+"'>"+vcw.getName()+"</a>\", ";
} catch (Exception e) {
json += "\"" + vcw.getName() + "\", ";
}
} else {
json += "\"\", ";
}
String shortDefStr = (vcw.getShortDef() == null) ? "" : vcw.getShortDef();
json += "\"data\": { \"shortDef\": \"" + shortDefStr + "\"}, \"children\": [] ";
if (classIt.hasNext())
json += "} , ";
else
json += "}] ";
}
}
else {
json += "\"children\": [] ";
}
json += "} ";
counter += 1;
}
}
body.put("jsonTree",json);
} catch (Throwable t) {
t.printStackTrace();
}
return new TemplateResponseValues(TEMPLATE_NAME, body);
}
}

141
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/ListVClassWebappsController.java Normal file
View file

@ -0,0 +1,141 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.freemarker;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.vocabulary.OWL;
import edu.cornell.mannlib.vitro.webapp.auth.permissions.SimplePermission;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.Actions;
import edu.cornell.mannlib.vitro.webapp.beans.Ontology;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.beans.VClassGroup;
import edu.cornell.mannlib.vitro.webapp.beans.ApplicationBean;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.ResponseValues;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.TemplateResponseValues;
import edu.cornell.mannlib.vitro.webapp.dao.OntologyDao;
import edu.cornell.mannlib.vitro.webapp.dao.PropertyDao;
import edu.cornell.mannlib.vitro.webapp.dao.VClassDao;
import edu.cornell.mannlib.vitro.webapp.dao.VClassGroupDao;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
public class ListVClassWebappsController extends FreemarkerHttpServlet {
private static final Log log = LogFactory.getLog(ListVClassWebappsController.class.getName());
private static final String TEMPLATE_NAME = "siteAdmin-classHierarchy.ftl";
@Override
protected Actions requiredActions(VitroRequest vreq) {
return SimplePermission.EDIT_ONTOLOGY.ACTIONS;
}
@Override
protected ResponseValues processRequest(VitroRequest vreq) {
Map<String, Object> body = new HashMap<String, Object>();
try {
body.put("displayOption", "all");
body.put("pageTitle", "All Classes");
List<VClass> classes = null;
if (vreq.getParameter("showPropertyRestrictions") != null) {
PropertyDao pdao = vreq.getFullWebappDaoFactory().getObjectPropertyDao();
classes = pdao.getClassesWithRestrictionOnProperty(vreq.getParameter("propertyURI"));
} else {
VClassDao vcdao = vreq.getFullWebappDaoFactory().getVClassDao();
if (vreq.getParameter("iffRoot") != null) {
classes = vcdao.getRootClasses();
} else {
classes = vcdao.getAllVclasses();
}
}
String json = new String();
int counter = 0;
String ontologyURI = vreq.getParameter("ontologyUri");
if (classes != null) {
Collections.sort(classes);
Iterator<VClass> classesIt = classes.iterator();
while (classesIt.hasNext()) {
if ( counter > 0 ) {
json += ", ";
}
VClass cls = (VClass) classesIt.next();
if ( (ontologyURI==null) || ( (ontologyURI != null) && (cls.getNamespace()!=null) && (ontologyURI.equals(cls.getNamespace())) ) ) {
if (cls.getName() != null)
try {
json += "{ \"name\": \"<a href='./vclassEdit?uri="+URLEncoder.encode(cls.getURI(),"UTF-8")+"'>"+cls.getLocalNameWithPrefix()+"</a>\", ";
} catch (Exception e) {
json += "{ \"name\": \"" + cls.getLocalNameWithPrefix() + "\", ";
}
else
json += "{ \"name\": \"\"";
String shortDef = (cls.getShortDef()==null) ? "" : cls.getShortDef();
json += "\"data\": { \"shortDef\": \"" + shortDef + "\", ";
// get group name
WebappDaoFactory wadf = vreq.getFullWebappDaoFactory();
VClassGroupDao groupDao= wadf.getVClassGroupDao();
String groupURI = cls.getGroupURI();
String groupName = "";
VClassGroup classGroup = null;
if(groupURI != null) {
classGroup = groupDao.getGroupByURI(groupURI);
if (classGroup!=null) {
groupName = classGroup.getPublicName();
}
}
json += "\"classGroup\": \"" + groupName + "\", ";
// get ontology name
OntologyDao ontDao = wadf.getOntologyDao();
String ontName = null;
try {
Ontology ont = ontDao.getOntologyByURI(cls.getNamespace());
ontName = ont.getName();
} catch (Exception e) {}
ontName = (ontName == null) ? "" : ontName;
json += "\"ontology\": \"" + ontName + "\"} }";
counter += 1;
}
}
body.put("jsonTree",json);
}
} catch (Throwable t) {
t.printStackTrace();
}
return new TemplateResponseValues(TEMPLATE_NAME, body);
}
}

4
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/MenuManagementController.java
View file

@ -282,9 +282,9 @@ public class MenuManagementController extends FreemarkerHttpServlet {
try{ try{
String className = DataGetterUtils.getJClassForDataGetterURI(displayModel, dataGetterURI); String className = DataGetterUtils.getJClassForDataGetterURI(displayModel, dataGetterURI);
//TODO: Change so that instantiation here occurs correctly <-- how should data getter be instantiated //TODO: Change so that instantiation here occurs correctly <-- how should data getter be instantiated
DataGetter pg = DataGetterUtils.dataGetterForURI(vreq.getDisplayModel(), dataGetterURI); DataGetter pg = DataGetterUtils.dataGetterForURI(vreq, vreq.getDisplayModel(), dataGetterURI);
//TODO: Check template data variable and what that is? //TODO: Check template data variable and what that is?
Map<String, Object> pageData = pg.getData(getServletContext(), vreq, templateData); Map<String, Object> pageData = pg.getData(templateData);
//Map<String, Object> pageInfo = vreq.getWebappDaoFactory().getPageDao().getPage(pageURI); //Map<String, Object> pageInfo = vreq.getWebappDaoFactory().getPageDao().getPage(pageURI);
SelectDataGetterUtils.processAndRetrieveData(vreq, getServletContext(), pageData, className, templateData); SelectDataGetterUtils.processAndRetrieveData(vreq, getServletContext(), pageData, className, templateData);
} catch(Exception ex) { } catch(Exception ex) {

9
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/PageController.java
View file

@ -23,7 +23,6 @@ import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.Tem
import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary; import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary;
import edu.cornell.mannlib.vitro.webapp.utils.dataGetter.DataGetter; import edu.cornell.mannlib.vitro.webapp.utils.dataGetter.DataGetter;
import edu.cornell.mannlib.vitro.webapp.utils.dataGetter.DataGetterUtils; import edu.cornell.mannlib.vitro.webapp.utils.dataGetter.DataGetterUtils;
import edu.cornell.mannlib.vitro.webapp.utils.pageDataGetter.PageDataGetterUtils;
/** /**
* Controller for getting data for pages defined in the display model. * Controller for getting data for pages defined in the display model.
* *
@ -68,7 +67,7 @@ public class PageController extends FreemarkerHttpServlet{
//executePageDataGetters( pageUri, vreq, getServletContext(), mapForTemplate ); //executePageDataGetters( pageUri, vreq, getServletContext(), mapForTemplate );
//these should all be data getters now //these should all be data getters now
executeDataGetters( pageUri, vreq, getServletContext(), mapForTemplate); executeDataGetters( pageUri, vreq, mapForTemplate);
mapForTemplate.putAll( getPageControllerValues( pageUri, vreq, getServletContext(), mapForTemplate)); mapForTemplate.putAll( getPageControllerValues( pageUri, vreq, getServletContext(), mapForTemplate));
@ -76,12 +75,12 @@ public class PageController extends FreemarkerHttpServlet{
return rv; return rv;
} }
private void executeDataGetters(String pageUri, VitroRequest vreq, ServletContext context, Map<String, Object> mapForTemplate) private void executeDataGetters(String pageUri, VitroRequest vreq, Map<String, Object> mapForTemplate)
throws Exception { throws Exception {
List<DataGetter> dgList = DataGetterUtils.getDataGettersForPage(vreq.getDisplayModel(), pageUri); List<DataGetter> dgList = DataGetterUtils.getDataGettersForPage(vreq, vreq.getDisplayModel(), pageUri);
for( DataGetter dg : dgList){ for( DataGetter dg : dgList){
Map<String,Object> moreData = dg.getData(context,vreq,mapForTemplate); Map<String,Object> moreData = dg.getData(mapForTemplate);
if( moreData != null ){ if( moreData != null ){
mapForTemplate.putAll(moreData); mapForTemplate.putAll(moreData);
} }

247
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/ShowClassHierarchyController.java Normal file
View file

@ -0,0 +1,247 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.freemarker;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.vocabulary.OWL;
import edu.cornell.mannlib.vitro.webapp.auth.permissions.SimplePermission;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.Actions;
import edu.cornell.mannlib.vitro.webapp.beans.Ontology;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.beans.VClassGroup;
import edu.cornell.mannlib.vitro.webapp.beans.ApplicationBean;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.ResponseValues;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.TemplateResponseValues;
import edu.cornell.mannlib.vitro.webapp.email.FreemarkerEmailFactory;
import edu.cornell.mannlib.vitro.webapp.dao.OntologyDao;
import edu.cornell.mannlib.vitro.webapp.dao.VClassDao;
import edu.cornell.mannlib.vitro.webapp.dao.VClassGroupDao;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
public class ShowClassHierarchyController extends FreemarkerHttpServlet {
private static final Log log = LogFactory.getLog(ShowClassHierarchyController.class.getName());
private static final String TEMPLATE_NAME = "siteAdmin-classHierarchy.ftl";
private int MAXDEPTH = 7;
private VClassDao vcDao = null;
private int previous_posn = 0;
private int childCount = 0;
private int uriCounter = 0;
@Override
protected Actions requiredActions(VitroRequest vreq) {
return SimplePermission.EDIT_ONTOLOGY.ACTIONS;
}
@Override
protected ResponseValues processRequest(VitroRequest vreq) {
Map<String, Object> body = new HashMap<String, Object>();
try {
String displayOption = "";
if ( vreq.getParameter("displayOption") != null ) {
displayOption = vreq.getParameter("displayOption");
}
else {
displayOption = "asserted";
}
body.put("displayOption", displayOption);
boolean inferred = ( displayOption.equals("inferred") );
if ( inferred ) {
body.put("pageTitle", "Inferred Class Hierarchy");
}
else {
body.put("pageTitle", "Asserted Class Hierarchy");
}
if (vreq.getAssertionsWebappDaoFactory() != null && !inferred) {
vcDao = vreq.getAssertionsWebappDaoFactory().getVClassDao();
} else {
vcDao = vreq.getFullWebappDaoFactory().getVClassDao();
}
String json = new String();
String ontologyUri = vreq.getParameter("ontologyUri");
String startClassUri = vreq.getParameter("vclassUri");
List<VClass> roots = null;
if (ontologyUri != null) {
roots = vcDao.getOntologyRootClasses(ontologyUri);
} else if (startClassUri != null) {
roots = new LinkedList<VClass>();
roots.add(vcDao.getVClassByURI(startClassUri));
} else {
roots = vcDao.getRootClasses();
}
if (roots.isEmpty()) {
roots = new LinkedList<VClass>();
roots.add(vreq.getFullWebappDaoFactory().getVClassDao()
.getTopConcept());
}
Collections.sort(roots);
int counter = 0;
Iterator rootIt = roots.iterator();
if (!rootIt.hasNext()) {
VClass vcw = new VClass();
vcw.setName("<strong>No classes found.</strong>");
json += addVClassDataToResultsList(vreq.getFullWebappDaoFactory(), vcw,0,ontologyUri,counter);
} else {
while (rootIt.hasNext()) {
VClass root = (VClass) rootIt.next();
if (root != null) {
json += addChildren(vreq.getFullWebappDaoFactory(), root, 0, ontologyUri,counter,"parent");
counter += 1;
}
}
int length = json.length();
if ( length > 0 ) {
json += " }";
}
}
body.put("jsonTree",json);
} catch (Throwable t) {
t.printStackTrace();
}
return new TemplateResponseValues(TEMPLATE_NAME, body);
}
private String addChildren(WebappDaoFactory wadf, VClass parent, int position, String ontologyUri, int counter, String status) {
String rowElts = addVClassDataToResultsList(wadf, parent, position, ontologyUri, counter);
int childShift = (rowElts.length() > 0) ? 1 : 0; // if addVClassDataToResultsList filtered out the result, don't shift the children over
int length = rowElts.length();
String leaves = "";
leaves += rowElts;
List childURIstrs = vcDao.getSubClassURIs(parent.getURI());
if ((childURIstrs.size()>0) && position<MAXDEPTH) {
List childClasses = new ArrayList();
Iterator childURIstrIt = childURIstrs.iterator();
while (childURIstrIt.hasNext()) {
String URIstr = (String) childURIstrIt.next();
try {
VClass child = (VClass) vcDao.getVClassByURI(URIstr);
if (!child.getURI().equals(OWL.Nothing.getURI())) {
childClasses.add(child);
}
} catch (Exception e) {}
}
Collections.sort(childClasses);
Iterator childClassIt = childClasses.iterator();
while (childClassIt.hasNext()) {
VClass child = (VClass) childClassIt.next();
leaves += addChildren(wadf, child, position + childShift, ontologyUri, counter, "child");
if (!childClassIt.hasNext()) {
if ( ontologyUri == null ) {
leaves += " }] ";
}
else if ( ontologyUri != null && length > 0 ) {
// need this for when we show the classes associated with an ontology
String ending = leaves.substring(leaves.length() - 2, leaves.length());
if ( ending.equals("] ") ) {
log.debug("[1] leaves += }]");
leaves += "}]";
}
else if ( ending.equals(" [") ){
log.debug("[2] leaves += ]");
leaves += "] ";
}
else {
log.debug("[3] leaves += }]");
leaves += "}]";
}
}
}
}
}
else {
if ( ontologyUri == null ) {
leaves += "] ";
}
else if ( ontologyUri != null && length > 0 ) {
leaves += "] ";
}
}
return leaves;
}
private String addVClassDataToResultsList(WebappDaoFactory wadf, VClass vcw, int position, String ontologyUri, int counter) {
String tempString = "";
if (ontologyUri == null || ( (vcw.getNamespace()!=null) && (vcw.getNamespace().equals(ontologyUri)) ) ) {
// first if statement ensures that the first class begins with correct format
if ( counter < 1 && position < 1 ) {
tempString += "{ \"name\": ";
}
else if ( position == previous_posn ) {
tempString += "}, { \"name\": ";
}
else if ( position > previous_posn ) {
tempString += " { \"name\": ";
}
else if ( position < previous_posn ) {
tempString += "}, { \"name\": ";
}
try {
tempString += "\"<a href='vclassEdit?uri="+URLEncoder.encode(vcw.getURI(),"UTF-8")+"'>"+vcw.getLocalNameWithPrefix()+"</a>\", ";
} catch (Exception e) {
tempString += "\" " + ((vcw.getLocalNameWithPrefix() == null) ? "" : vcw.getLocalNameWithPrefix()) + "\", ";
}
tempString += "\"data\": { \"shortDef\": \"" + ((vcw.getShortDef() == null) ? "" : vcw.getShortDef()) + "\", ";
// Get group name if it exists
VClassGroupDao groupDao= wadf.getVClassGroupDao();
String groupURI = vcw.getGroupURI();
String groupName = null;
VClassGroup classGroup = null;
if(groupURI != null) {
classGroup = groupDao.getGroupByURI(groupURI);
if (classGroup != null) {
groupName = classGroup.getPublicName();
}
}
tempString += "\"classGroup\": \"" + ((groupName == null) ? "" : groupName) + "\", ";
// Get ontology name
String ontName = null;
try {
OntologyDao ontDao = wadf.getOntologyDao();
Ontology ont = ontDao.getOntologyByURI(vcw.getNamespace());
ontName = ont.getName();
} catch (Exception e) {}
tempString += "\"ontology\": \"" + ((ontName == null) ? "" : ontName) + "\"}, \"children\": [";
previous_posn = position;
}
return tempString;
}
}

25
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/TemplateProcessingHelper.java
View file

@ -13,7 +13,7 @@ import javax.servlet.http.HttpServletRequest;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.ResponseValues; import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import freemarker.core.Environment; import freemarker.core.Environment;
import freemarker.template.Configuration; import freemarker.template.Configuration;
import freemarker.template.Template; import freemarker.template.Template;
@ -27,8 +27,8 @@ public class TemplateProcessingHelper {
private HttpServletRequest request = null; private HttpServletRequest request = null;
private ServletContext context = null; private ServletContext context = null;
public TemplateProcessingHelper(Configuration config, HttpServletRequest request, ServletContext context) { public TemplateProcessingHelper(HttpServletRequest request, ServletContext context) {
this.config = config; this.config = FreemarkerConfigurationLoader.getConfig(new VitroRequest(request));
this.request = request; this.request = request;
this.context = context; this.context = context;
} }
@ -41,13 +41,6 @@ public class TemplateProcessingHelper {
return sw; return sw;
} }
protected StringWriter processTemplate(ResponseValues values) throws TemplateProcessingException {
if (values == null) {
return null;
}
return processTemplate(values.getTemplateName(), values.getMap());
}
private void processTemplate(Template template, Map<String, Object> map, Writer writer) private void processTemplate(Template template, Map<String, Object> map, Writer writer)
throws TemplateProcessingException { throws TemplateProcessingException {
@ -72,18 +65,6 @@ public class TemplateProcessingHelper {
} }
} }
// For cases where we need a String instead of a StringWriter. StringWriter objects can be put in the template data model,
// but we can use this method from a jsp, for example.
public String processTemplateToString(String templateName, Map<String, Object> map)
throws TemplateProcessingException {
return processTemplate(templateName, map).toString();
}
protected String processTemplateToString(ResponseValues values)
throws TemplateProcessingException {
return processTemplate(values).toString();
}
private Template getTemplate(String templateName) throws TemplateProcessingException { private Template getTemplate(String templateName) throws TemplateProcessingException {
Template template = null; Template template = null;
try { try {

28
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/individual/IndividualRdfAssembler.java
View file

@ -126,21 +126,19 @@ public class IndividualRdfAssembler {
newModel = getLabelAndTypes(entity, contextModel, newModel ); newModel = getLabelAndTypes(entity, contextModel, newModel );
// get all the statements not covered by the object property / datatype property code above //bdc34: The following code adds all triples where entity is the Subject.
// note implication that extendedLinkedData individuals will only be evaluated for the // contextModel.enterCriticalSection(Lock.READ);
// recognized object properties. // try {
contextModel.enterCriticalSection(Lock.READ); // StmtIterator iter = contextModel.listStatements(subj, (Property) null, (RDFNode) null);
try { // while (iter.hasNext()) {
StmtIterator iter = contextModel.listStatements(subj, (Property) null, (RDFNode) null); // Statement stmt = iter.next();
while (iter.hasNext()) { // if (!newModel.contains(stmt)) {
Statement stmt = iter.next(); // newModel.add(stmt);
if (!newModel.contains(stmt)) { // }
newModel.add(stmt); // }
} // } finally {
} // contextModel.leaveCriticalSection();
} finally { // }
contextModel.leaveCriticalSection();
}
if (recurseDepth == 0 && includes != null && entity.isVClass(PERSON_CLASS_URI)) { if (recurseDepth == 0 && includes != null && entity.isVClass(PERSON_CLASS_URI)) {

4
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/jena/JenaIngestController.java
View file

@ -73,7 +73,7 @@ import edu.cornell.mannlib.vitro.webapp.dao.jena.VitroJenaModelMaker;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VitroJenaSDBModelMaker; import edu.cornell.mannlib.vitro.webapp.dao.jena.VitroJenaSDBModelMaker;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VitroJenaSpecialModelMaker; import edu.cornell.mannlib.vitro.webapp.dao.jena.VitroJenaSpecialModelMaker;
import edu.cornell.mannlib.vitro.webapp.dao.jena.event.EditEvent; import edu.cornell.mannlib.vitro.webapp.dao.jena.event.EditEvent;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.JenaDataSourceSetup; import edu.cornell.mannlib.vitro.webapp.servlet.setup.WebappDaoSDBSetup;
import edu.cornell.mannlib.vitro.webapp.utils.SparqlQueryUtils; import edu.cornell.mannlib.vitro.webapp.utils.SparqlQueryUtils;
import edu.cornell.mannlib.vitro.webapp.utils.jena.JenaIngestUtils; import edu.cornell.mannlib.vitro.webapp.utils.jena.JenaIngestUtils;
import edu.cornell.mannlib.vitro.webapp.utils.jena.JenaIngestUtils.MergeResult; import edu.cornell.mannlib.vitro.webapp.utils.jena.JenaIngestUtils.MergeResult;
@ -942,7 +942,7 @@ public class JenaIngestController extends BaseEditController {
log.debug("Connecting to DB at "+jdbcUrl); log.debug("Connecting to DB at "+jdbcUrl);
StoreDesc storeDesc = new StoreDesc(LayoutType.LayoutTripleNodesHash,dbTypeObj) ; StoreDesc storeDesc = new StoreDesc(LayoutType.LayoutTripleNodesHash,dbTypeObj) ;
ServletContext ctx = vreq.getSession().getServletContext(); ServletContext ctx = vreq.getSession().getServletContext();
BasicDataSource bds = JenaDataSourceSetup.makeBasicDataSource( BasicDataSource bds = WebappDaoSDBSetup.makeBasicDataSource(
driver, jdbcUrl, username, password, ctx); driver, jdbcUrl, username, password, ctx);
try { try {
VitroJenaSDBModelMaker vsmm = new VitroJenaSDBModelMaker(storeDesc, bds); VitroJenaSDBModelMaker vsmm = new VitroJenaSDBModelMaker(storeDesc, bds);

39
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/json/GetDataForPage.java Normal file
View file

@ -0,0 +1,39 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.json;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONObject;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.utils.pageDataGetter.PageDataGetterUtils;
/**
* Gets data based on data getter for page uri and returns in the form of Json objects
*/
public class GetDataForPage extends JsonObjectProducer {
private static final Log log = LogFactory.getLog(GetDataForPage.class);
protected GetDataForPage(VitroRequest vreq) {
super(vreq);
}
@Override
protected JSONObject process() throws Exception {
JSONObject rObj = null;
String pageUri = vreq.getParameter("pageUri");
if(pageUri != null && !pageUri.isEmpty()) {
Map<String,Object> data = PageDataGetterUtils.getDataForPage(pageUri, vreq, ctx);
//Convert to json version based on type of page
if(data != null) {
//Convert to json version based on type of page
rObj = PageDataGetterUtils.covertDataToJSONForPage(pageUri, data, vreq, ctx);
}
}
return rObj;
}
}

125
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/json/GetEntitiesByVClass.java Normal file
View file

@ -0,0 +1,125 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.json;
import static edu.cornell.mannlib.vitro.webapp.controller.json.JsonServlet.REPLY_SIZE;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
import javax.servlet.ServletException;
import javax.servlet.http.HttpSession;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
/**
* Gets a list of entities that are members of the indicated vClass.
*
* If the list is large then we will pass some token indicating that there is more
* to come. The results are sent back in 250 entity blocks. To get all of the
* entities for a VClass just keep requesting lists until there are not more
* continue tokens.
*
* If there are more entities the last item on the returned array will be an object
* with no id property. It will look like this:
*
* {"resultGroup":0,
* "resultKey":"2WEK2306",
* "nextUrl":"http://caruso.mannlib.cornell.edu:8080/vitro/dataservice?getEntitiesByVClass=1&resultKey=2WEK2306&resultGroup=1&vclassId=null",
* "entsInVClass":1752,
* "nextResultGroup":1,
* "standardReplySize":256}
*
*/
public class GetEntitiesByVClass extends JsonArrayProducer {
private static final Log log = LogFactory.getLog(GetEntitiesByVClass.class);
protected GetEntitiesByVClass(VitroRequest vreq) {
super(vreq);
}
@Override
protected JSONArray process() throws ServletException {
log.debug("in getEntitiesByVClass()");
String vclassURI = vreq.getParameter("vclassURI");
WebappDaoFactory daos = vreq.getFullWebappDaoFactory();
if( vclassURI == null ){
throw new ServletException("getEntitiesByVClass(): no value for 'vclassURI' found in the HTTP request");
}
VClass vclass = daos.getVClassDao().getVClassByURI( vclassURI );
if( vclass == null ){
throw new ServletException("getEntitiesByVClass(): could not find vclass for uri '"+ vclassURI + "'");
}
List<Individual> entsInVClass = daos.getIndividualDao().getIndividualsByVClass( vclass );
if( entsInVClass == null ){
throw new ServletException("getEntitiesByVClass(): null List<Individual> retruned by getIndividualsByVClass() for "+vclassURI);
}
int numberOfEntsInVClass = entsInVClass.size();
List<Individual> entsToReturn = new ArrayList<Individual>( REPLY_SIZE );
String requestHash = null;
int count = 0;
boolean more = false;
/* we have a large number of items to send back so we need to stash the list in the session scope */
if( entsInVClass.size() > REPLY_SIZE){
more = true;
HttpSession session = vreq.getSession(true);
requestHash = Integer.toString((vclassURI + System.currentTimeMillis()).hashCode());
session.setAttribute(requestHash, entsInVClass );
ListIterator<Individual> entsFromVclass = entsInVClass.listIterator();
while ( entsFromVclass.hasNext() && count < REPLY_SIZE ){
entsToReturn.add( entsFromVclass.next());
entsFromVclass.remove();
count++;
}
if( log.isDebugEnabled() ){ log.debug("getEntitiesByVClass(): Creating reply with continue token, found " + numberOfEntsInVClass + " Individuals"); }
}else{
if( log.isDebugEnabled() ) log.debug("getEntitiesByVClass(): sending " + numberOfEntsInVClass +" Individuals without continue token");
entsToReturn = entsInVClass;
count = entsToReturn.size();
}
//put all the entities on the JSON array
JSONArray ja = individualsToJson( entsToReturn );
//put the responseGroup number on the end of the JSON array
if( more ){
try{
JSONObject obj = new JSONObject();
obj.put("resultGroup", "true");
obj.put("size", count);
obj.put("total", numberOfEntsInVClass);
StringBuffer nextUrlStr = vreq.getRequestURL();
nextUrlStr.append("?")
.append("getEntitiesByVClass").append( "=1&" )
.append("resultKey=").append( requestHash );
obj.put("nextUrl", nextUrlStr.toString());
ja.put(obj);
}catch(JSONException je ){
throw new ServletException("unable to create continuation as JSON: " + je.getMessage());
}
}
log.debug("done with getEntitiesByVClass()");
return ja;
}
}

96
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/json/GetEntitiesByVClassContinuation.java Normal file
View file

@ -0,0 +1,96 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.json;
import static edu.cornell.mannlib.vitro.webapp.controller.json.JsonServlet.REPLY_SIZE;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
import javax.servlet.ServletException;
import javax.servlet.http.HttpSession;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
/**
*
*/
public class GetEntitiesByVClassContinuation extends JsonArrayProducer {
private static final Log log = LogFactory
.getLog(GetEntitiesByVClassContinuation.class);
protected GetEntitiesByVClassContinuation(VitroRequest vreq) {
super(vreq);
}
@Override
protected JSONArray process() throws ServletException {
log.debug("in getEntitiesByVClassContinuation()");
String resKey = vreq.getParameter("resultKey");
if( resKey == null )
throw new ServletException("Could not get resultKey");
HttpSession session = vreq.getSession();
if( session == null )
throw new ServletException("there is no session to get the pervious results from");
@SuppressWarnings("unchecked")
List<Individual> entsInVClass = (List<Individual>) session.getAttribute(resKey);
if( entsInVClass == null )
throw new ServletException("Could not find List<Individual> for resultKey " + resKey);
List<Individual> entsToReturn = new ArrayList<Individual>(REPLY_SIZE);
boolean more = false;
int count = 0;
/* we have a large number of items to send back so we need to stash the list in the session scope */
if( entsInVClass.size() > REPLY_SIZE){
more = true;
ListIterator<Individual> entsFromVclass = entsInVClass.listIterator();
while ( entsFromVclass.hasNext() && count <= REPLY_SIZE ){
entsToReturn.add( entsFromVclass.next());
entsFromVclass.remove();
count++;
}
if( log.isDebugEnabled() ) log.debug("getEntitiesByVClassContinuation(): Creating reply with continue token," +
" sending in this reply: " + count +", remaing to send: " + entsInVClass.size() );
} else {
//send out reply with no continuation
entsToReturn = entsInVClass;
count = entsToReturn.size();
session.removeAttribute(resKey);
if( log.isDebugEnabled()) log.debug("getEntitiesByVClassContinuation(): sending " + count + " Ind without continue token");
}
//put all the entities on the JSON array
JSONArray ja = individualsToJson( entsToReturn );
//put the responseGroup number on the end of the JSON array
if( more ){
try{
JSONObject obj = new JSONObject();
obj.put("resultGroup", "true");
obj.put("size", count);
StringBuffer nextUrlStr = vreq.getRequestURL();
nextUrlStr.append("?")
.append("getEntitiesByVClass").append( "=1&" )
.append("resultKey=").append( resKey );
obj.put("nextUrl", nextUrlStr.toString());
ja.put(obj);
}catch(JSONException je ){
throw new ServletException(je.getMessage());
}
}
log.debug("done with getEntitiesByVClassContinuation()");
return ja;
}
}

79
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/json/GetRenderedSolrIndividualsByVClass.java Normal file
View file

@ -0,0 +1,79 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.json;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.IndividualDao;
import edu.cornell.mannlib.vitro.webapp.services.shortview.ShortViewService;
import edu.cornell.mannlib.vitro.webapp.services.shortview.ShortViewService.ShortViewContext;
import edu.cornell.mannlib.vitro.webapp.services.shortview.ShortViewServiceSetup;
import edu.cornell.mannlib.vitro.webapp.web.templatemodels.individual.IndividualTemplateModel;
/**
* Does a Solr search for individuals, and uses the short view to render each of
* the results.
*/
public class GetRenderedSolrIndividualsByVClass extends JsonObjectProducer {
private static final Log log = LogFactory
.getLog(GetRenderedSolrIndividualsByVClass.class);
protected GetRenderedSolrIndividualsByVClass(VitroRequest vreq) {
super(vreq);
}
/**
* Search for individuals by VClass. The class URI and the paging
* information are in the request parameters.
*/
@Override
protected JSONObject process() throws Exception {
JSONObject rObj = null;
VClass vclass = getVclassParameter(vreq);
String vclassId = vclass.getURI();
vreq.setAttribute("displayType", vclassId);
rObj = JsonServlet.getSolrIndividualsByVClass(vclassId, vreq, ctx);
addShortViewRenderings(rObj);
return rObj;
}
/**
* Look through the return object. For each individual, render the short
* view and insert the resulting HTML into the object.
*/
private void addShortViewRenderings(JSONObject rObj) throws JSONException {
JSONArray individuals = rObj.getJSONArray("individuals");
String vclassName = rObj.getJSONObject("vclass").getString("name");
for (int i = 0; i < individuals.length(); i++) {
JSONObject individual = individuals.getJSONObject(i);
individual.put("shortViewHtml",
renderShortView(individual.getString("URI"), vclassName));
}
}
private String renderShortView(String individualUri, String vclassName) {
IndividualDao iDao = vreq.getWebappDaoFactory().getIndividualDao();
Individual individual = iDao.getIndividualByURI(individualUri);
Map<String, Object> modelMap = new HashMap<String, Object>();
modelMap.put("individual",
new IndividualTemplateModel(individual, vreq));
modelMap.put("vclass", vclassName);
ShortViewService svs = ShortViewServiceSetup.getService(ctx);
return svs.renderShortView(individual, ShortViewContext.BROWSE,
modelMap, vreq);
}
}

42
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/json/GetSolrIndividualsByVClass.java Normal file
View file

@ -0,0 +1,42 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.json;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONObject;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
/**
*
*/
public class GetSolrIndividualsByVClass extends JsonObjectProducer {
private static final Log log = LogFactory
.getLog(GetSolrIndividualsByVClass.class);
protected GetSolrIndividualsByVClass(VitroRequest vreq) {
super(vreq);
}
@Override
protected JSONObject process() throws Exception {
VClass vclass=null;
String vitroClassIdStr = vreq.getParameter("vclassId");
if ( vitroClassIdStr != null && !vitroClassIdStr.isEmpty()){
vclass = vreq.getWebappDaoFactory().getVClassDao().getVClassByURI(vitroClassIdStr);
if (vclass == null) {
log.debug("Couldn't retrieve vclass ");
throw new Exception ("Class " + vitroClassIdStr + " not found");
}
}else{
log.debug("parameter vclassId URI parameter expected ");
throw new Exception("parameter vclassId URI parameter expected ");
}
vreq.setAttribute("displayType", vitroClassIdStr);
return JsonServlet.getSolrIndividualsByVClass(vclass.getURI(), vreq, ctx);
}
}

51
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/json/GetSolrIndividualsByVClasses.java Normal file
View file

@ -0,0 +1,51 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.json;
import java.util.Arrays;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONObject;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
/**
* Accepts multiple vclasses and returns individuals which correspond to the
* intersection of those classes (i.e. have all those types)
*/
public class GetSolrIndividualsByVClasses extends JsonObjectProducer {
private static final Log log = LogFactory
.getLog(GetSolrIndividualsByVClasses.class);
public GetSolrIndividualsByVClasses(VitroRequest vreq) {
super(vreq);
}
@Override
protected JSONObject process() throws Exception {
log.debug("Executing retrieval of individuals by vclasses");
VClass vclass=null;
log.debug("Retrieving solr individuals by vclasses");
// Could have multiple vclass ids sent in
String[] vitroClassIdStr = vreq.getParameterValues("vclassId");
if ( vitroClassIdStr != null && vitroClassIdStr.length > 0){
for(String vclassId: vitroClassIdStr) {
log.debug("Iterating throug vclasses, using VClass " + vclassId);
vclass = vreq.getWebappDaoFactory().getVClassDao().getVClassByURI(vclassId);
if (vclass == null) {
log.error("Couldn't retrieve vclass ");
throw new Exception ("Class " + vclassId + " not found");
}
}
}else{
log.error("parameter vclassId URI parameter expected but not found");
throw new Exception("parameter vclassId URI parameter expected ");
}
List<String> vclassIds = Arrays.asList(vitroClassIdStr);
return JsonServlet.getSolrIndividualsByVClasses(vclassIds, vreq, ctx);
}
}

56
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/json/GetVClassesForVClassGroup.java Normal file
View file

@ -0,0 +1,56 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.json;
import java.util.ArrayList;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONObject;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.beans.VClassGroup;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VClassGroupCache;
/**
*
*/
public class GetVClassesForVClassGroup extends JsonObjectProducer {
private static final Log log = LogFactory
.getLog(GetVClassesForVClassGroup.class);
public GetVClassesForVClassGroup(VitroRequest vreq) {
super(vreq);
}
@Override
protected JSONObject process() throws Exception {
JSONObject map = new JSONObject();
String vcgUri = vreq.getParameter("classgroupUri");
if( vcgUri == null ){
throw new Exception("no URI passed for classgroupUri");
}
VClassGroupCache vcgc = VClassGroupCache.getVClassGroupCache(ctx);
VClassGroup vcg = vcgc.getGroup(vcgUri);
if( vcg == null ){
throw new Exception("Could not find vclassgroup: " + vcgUri);
}
ArrayList<JSONObject> classes = new ArrayList<JSONObject>(vcg.size());
for( VClass vc : vcg){
JSONObject vcObj = new JSONObject();
vcObj.put("name", vc.getName());
vcObj.put("URI", vc.getURI());
vcObj.put("entityCount", vc.getEntityCount());
classes.add(vcObj);
}
map.put("classes", classes);
map.put("classGroupName", vcg.getPublicName());
map.put("classGroupUri", vcg.getURI());
return map;
}
}

60
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/json/JsonArrayProducer.java Normal file
View file

@ -0,0 +1,60 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.json;
import java.io.IOException;
import java.io.Writer;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONArray;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
/**
* A base for classes that produce a JSON array based on the parameters in the
* VitroRequest.
*
* Catches any exceptions. Logs the error and returns an empty JSON array.
*/
public abstract class JsonArrayProducer extends JsonProducer {
private static final Log log = LogFactory.getLog(JsonArrayProducer.class);
protected final VitroRequest vreq;
protected final ServletContext ctx;
protected JsonArrayProducer(VitroRequest vreq) {
this.vreq = vreq;
this.ctx = vreq.getSession().getServletContext();
}
/**
* Sub-classes implement this method. Given the request, produce a JSON
* object as the result.
*/
protected abstract JSONArray process() throws Exception;
public final void process(HttpServletResponse resp) throws IOException {
JSONArray jsonArray = null;
try {
jsonArray = process();
} catch (Exception e) {
log.error("Failed to create JSON response" + e);
resp.setStatus(500 /* HttpURLConnection.HTTP_SERVER_ERROR */);
}
if (jsonArray == null) {
jsonArray = new JSONArray();
}
log.debug("Response to JSON request: " + jsonArray.toString());
resp.setCharacterEncoding("UTF-8");
resp.setContentType("application/json;charset=UTF-8");
Writer writer = resp.getWriter();
writer.write(jsonArray.toString());
}
}

76
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/json/JsonObjectProducer.java Normal file
View file

@ -0,0 +1,76 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.json;
import java.io.IOException;
import java.io.Writer;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONException;
import org.json.JSONObject;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
/**
* A base for classes that produce a JSON object, based on the parameters in the
* request.
*
* The result is never empty. At worst, it is an object that contains only an
* "errorMessage" field.
*
* If an exception occurrs during processing, The "errorMessage" field will
* contain the exception message and the response status will be set to 500
* (server error). Normally, "errorMessage" will be empty, and the status will
* default to 200 (OK).
*/
public abstract class JsonObjectProducer extends JsonProducer {
private static final Log log = LogFactory.getLog(JsonObjectProducer.class);
protected final VitroRequest vreq;
protected final ServletContext ctx;
protected JsonObjectProducer(VitroRequest vreq) {
this.vreq = vreq;
this.ctx = vreq.getSession().getServletContext();
}
/**
* Sub-classes implement this method. Given the request, produce a JSON
* object as the result.
*/
protected abstract JSONObject process() throws Exception;
public final void process(HttpServletResponse resp) throws IOException {
JSONObject jsonObject = null;
String errorMessage = "";
try {
jsonObject = process();
} catch (Exception e) {
log.error("Failed to create JSON response" + e);
errorMessage = e.toString();
resp.setStatus(500 /* HttpURLConnection.HTTP_SERVER_ERROR */);
}
if (jsonObject == null) {
jsonObject = new JSONObject();
}
log.debug("Response to JSON request: " + jsonObject.toString());
try {
resp.setCharacterEncoding("UTF-8");
resp.setContentType("application/json;charset=UTF-8");
Writer writer = resp.getWriter();
jsonObject.put("errorMessage", errorMessage);
writer.write(jsonObject.toString());
} catch (JSONException e) {
log.error(e, e);
}
}
}

89
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/json/JsonProducer.java Normal file
View file

@ -0,0 +1,89 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.json;
import java.util.Arrays;
import java.util.List;
import javax.servlet.ServletException;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
/**
* A base for the classes that produce JSON results. Contains some useful constants and convenience methods.
*/
public abstract class JsonProducer {
private static final Log log = LogFactory.getLog(JsonProducer.class);
/**
* Process a list of Individuals into a JSON array that holds the Names and URIs.
*/
protected JSONArray individualsToJson(List<Individual> individuals) throws ServletException {
try{
JSONArray ja = new JSONArray();
for (Individual ent: individuals) {
JSONObject entJ = new JSONObject();
entJ.put("name", ent.getName());
entJ.put("URI", ent.getURI());
ja.put( entJ );
}
return ja;
}catch(JSONException ex){
throw new ServletException("could not convert list of Individuals into JSON: " + ex);
}
}
/**
* Get the "vclassId" parameter from the request and instantiate the VClass.
*
* There must be one, and it must be valid.
*/
protected VClass getVclassParameter(VitroRequest vreq) {
String vclassId = vreq.getParameter("vclassId");
if (StringUtils.isEmpty(vclassId)) {
log.error("parameter vclassId expected but not found");
throw new IllegalStateException("parameter vclassId expected ");
}
return instantiateVclass(vclassId, vreq);
}
/**
* Get one or more "vclassId" parameters from the request. Confirm that
* there is at least one, and that all are valid.
*
* Return value is never null and never empty.
*/
protected List<String> getVclassIds(VitroRequest vreq) {
String[] vclassIds = vreq.getParameterValues("vclassId");
if ((vclassIds == null) || (vclassIds.length == 0)) {
log.error("parameter vclassId expected but not found");
throw new IllegalStateException("parameter vclassId expected ");
}
for (String vclassId : vclassIds) {
instantiateVclass(vclassId, vreq);
}
return Arrays.asList(vclassIds);
}
private VClass instantiateVclass(String uri, VitroRequest vreq) {
VClass vclass = vreq.getWebappDaoFactory().getVClassDao()
.getVClassByURI(uri);
if (vclass == null) {
log.error("Couldn't retrieve vclass ");
throw new IllegalStateException("Class " + uri + " not found");
}
return vclass;
}
}

141
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/json/JsonServlet.java Normal file
View file

@ -0,0 +1,141 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.controller.json;
import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONObject;
import edu.cornell.mannlib.vitro.webapp.beans.DataProperty;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.controller.VitroHttpServlet;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.IndividualListController;
import edu.cornell.mannlib.vitro.webapp.dao.ObjectPropertyStatementDao;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.utils.log.LogUtils;
import edu.cornell.mannlib.vitro.webapp.utils.pageDataGetter.PageDataGetterUtils;
/**
* This servlet is for servicing requests for JSON objects/data.
* It could be generalized to get other types of data ex. XML, HTML etc
* @author bdc34
*
* Moved most of the logic into a group of JsonProducer classes. jeb228
*/
public class JsonServlet extends VitroHttpServlet {
private static final long serialVersionUID = 1L;
private static final Log log = LogFactory.getLog(JsonServlet.class);
private static final int INDIVIDUALS_PER_PAGE = 30;
public static final int REPLY_SIZE = 256;
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doGet(req, resp);
log.debug(LogUtils.formatRequestProperties(log, "debug", req));
VitroRequest vreq = new VitroRequest(req);
if (vreq.getParameter("getEntitiesByVClass") != null) {
if( vreq.getParameter("resultKey") == null) {
new GetEntitiesByVClass(vreq).process(resp);
} else {
new GetEntitiesByVClassContinuation(vreq).process(resp);
}
}else if( vreq.getParameter("getN3EditOptionList") != null ){
throw new IllegalArgumentException("The call invoked deprecated classes " +
"and the parameter for this call appeared nowhere in the code base, " +
"so it was removed in May, 2012.");
}else if( vreq.getParameter("getSolrIndividualsByVClass") != null ){
new GetSolrIndividualsByVClass(vreq).process(resp);
}else if( vreq.getParameter("getVClassesForVClassGroup") != null ){
new GetVClassesForVClassGroup(vreq).process(resp);
} else if( vreq.getParameter("getSolrIndividualsByVClasses") != null ){
log.debug("AJAX request to retrieve individuals by vclasses");
new GetSolrIndividualsByVClasses(vreq).process(resp);
} else if( vreq.getParameter("getDataForPage") != null ){
new GetDataForPage(vreq).process(resp);
}else if( vreq.getParameter("getRenderedSolrIndividualsByVClass") != null ){
new GetRenderedSolrIndividualsByVClass(vreq).process(resp);
}
}
public static JSONObject getSolrIndividualsByVClass(String vclassURI, HttpServletRequest req, ServletContext context) throws Exception {
List<String> vclassURIs = Collections.singletonList(vclassURI);
VitroRequest vreq = new VitroRequest(req);
Map<String, Object> map = getSolrVClassIntersectionResults(vclassURIs, vreq, context);
//last parameter indicates single vclass instead of multiple vclasses
return processVClassResults(map, vreq, context, false);
}
public static JSONObject getSolrIndividualsByVClasses(List<String> vclassURIs, HttpServletRequest req, ServletContext context) throws Exception {
VitroRequest vreq = new VitroRequest(req);
log.debug("Retrieve solr results for vclasses" + vclassURIs.toString());
Map<String, Object> map = getSolrVClassIntersectionResults(vclassURIs, vreq, context);
log.debug("Results returned from Solr for " + vclassURIs.toString() + " are of size " + map.size());
JSONObject rObj = processVClassResults(map, vreq, context, true);
return rObj;
}
//Including version for Solr query for Vclass Intersections
private static Map<String,Object> getSolrVClassIntersectionResults(List<String> vclassURIs, VitroRequest vreq, ServletContext context){
log.debug("Retrieving Solr intersection results for " + vclassURIs.toString());
String alpha = IndividualListController.getAlphaParameter(vreq);
int page = IndividualListController.getPageParameter(vreq);
log.debug("Alpha and page parameters are " + alpha + " and " + page);
Map<String,Object> map = null;
try {
map = IndividualListController.getResultsForVClassIntersections(
vclassURIs,
page, INDIVIDUALS_PER_PAGE,
alpha,
vreq.getWebappDaoFactory().getIndividualDao(),
context);
} catch(Exception ex) {
log.error("Error in retrieval of search results for VClass " + vclassURIs.toString(), ex);
}
return map;
}
// Map given to process method includes the actual individuals returned from the search
public static JSONObject processVClassResults(Map<String, Object> map, VitroRequest vreq, ServletContext context, boolean multipleVclasses) throws Exception{
JSONObject rObj = PageDataGetterUtils.processVclassResultsJSON(map, vreq, multipleVclasses);
return rObj;
}
public static Collection<String> getMostSpecificTypes(Individual individual, WebappDaoFactory wdf) {
ObjectPropertyStatementDao opsDao = wdf.getObjectPropertyStatementDao();
Map<String, String> mostSpecificTypes = opsDao.getMostSpecificTypesInClassgroupsForIndividual(individual.getURI());
return mostSpecificTypes.values();
}
public static String getDataPropertyValue(Individual ind, DataProperty dp, WebappDaoFactory wdf){
String value = ind.getDataValue(dp.getURI());
if( value == null || value.isEmpty() )
return "";
else
return value;
}
}

5
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/login/LoginTemplateHelper.java
View file

@ -18,7 +18,6 @@ import edu.cornell.mannlib.vitro.webapp.controller.freemarker.FreemarkerHttpServ
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.TemplateProcessingHelper.TemplateProcessingException; import edu.cornell.mannlib.vitro.webapp.controller.freemarker.TemplateProcessingHelper.TemplateProcessingException;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.TemplateResponseValues; import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.TemplateResponseValues;
import edu.cornell.mannlib.vitro.webapp.controller.login.LoginProcessBean.State; import edu.cornell.mannlib.vitro.webapp.controller.login.LoginProcessBean.State;
import freemarker.template.Configuration;
/** /**
* A temporary means of displaying the Login templates within the SiteAdmin * A temporary means of displaying the Login templates within the SiteAdmin
@ -164,13 +163,11 @@ public class LoginTemplateHelper extends LoginTemplateHelperBase {
*/ */
private String doTemplate(VitroRequest vreq, TemplateResponseValues values) throws TemplateProcessingException { private String doTemplate(VitroRequest vreq, TemplateResponseValues values) throws TemplateProcessingException {
// Set it up like FreeMarkerHttpServlet.doGet() would do. // Set it up like FreeMarkerHttpServlet.doGet() would do.
Configuration config = getConfig(vreq);
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.putAll(getPageTemplateValues(vreq)); map.putAll(getPageTemplateValues(vreq));
map.putAll(values.getMap()); map.putAll(values.getMap());
return processTemplateToString(values.getTemplateName(), map, config, vreq); return processTemplateToString(values.getTemplateName(), map, vreq);
} }
/** /**

5
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/filtering/IndividualFiltering.java
View file

@ -369,11 +369,6 @@ public class IndividualFiltering implements Individual {
return _innerIndividual.isVClass(uri); return _innerIndividual.isVClass(uri);
} }
@Override
public boolean isMemberOfClassProhibitedFromSearch(ProhibitedFromSearch pfs) {
return _innerIndividual.isMemberOfClassProhibitedFromSearch(pfs);
}
@Override @Override
public void setDataPropertyMap(Map<String, DataProperty> propertyMap) { public void setDataPropertyMap(Map<String, DataProperty> propertyMap) {
_innerIndividual.setDataPropertyMap(propertyMap); _innerIndividual.setDataPropertyMap(propertyMap);

26
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/IndividualJena.java
View file

@ -28,7 +28,6 @@ import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.shared.Lock; import com.hp.hpl.jena.shared.Lock;
import com.hp.hpl.jena.util.iterator.ClosableIterator; import com.hp.hpl.jena.util.iterator.ClosableIterator;
import com.hp.hpl.jena.vocabulary.OWL; import com.hp.hpl.jena.vocabulary.OWL;
import com.hp.hpl.jena.vocabulary.RDF;
import edu.cornell.mannlib.vitro.webapp.beans.DataProperty; import edu.cornell.mannlib.vitro.webapp.beans.DataProperty;
import edu.cornell.mannlib.vitro.webapp.beans.DataPropertyStatement; import edu.cornell.mannlib.vitro.webapp.beans.DataPropertyStatement;
@ -41,7 +40,6 @@ import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.dao.VClassDao; import edu.cornell.mannlib.vitro.webapp.dao.VClassDao;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary; import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.filestorage.model.ImageInfo; import edu.cornell.mannlib.vitro.webapp.filestorage.model.ImageInfo;
import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch;
public class IndividualJena extends IndividualImpl implements Individual { public class IndividualJena extends IndividualImpl implements Individual {
@ -509,30 +507,6 @@ public class IndividualJena extends IndividualImpl implements Individual {
return false; return false;
} }
@Override
public boolean isMemberOfClassProhibitedFromSearch(ProhibitedFromSearch pfs) {
ind.getModel().enterCriticalSection(Lock.READ);
try {
StmtIterator stmtIt = ind.listProperties(RDF.type);
try {
while(stmtIt.hasNext()) {
Statement stmt = stmtIt.nextStatement();
if (stmt.getObject().isURIResource()) {
String typeURI = ((Resource)stmt.getObject()).getURI();
if (pfs.isClassProhibitedFromSearch(typeURI)) {
return true;
}
}
}
} finally {
stmtIt.close();
}
return false;
} finally {
ind.getModel().leaveCriticalSection();
}
}
/** /**
* Overriding the base method so that we can do the sorting by arbitrary property here. An * Overriding the base method so that we can do the sorting by arbitrary property here. An
* IndividualJena has a reference back to the model; everything else is just a dumb bean (for now). * IndividualJena has a reference back to the model; everything else is just a dumb bean (for now).

17
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/IndividualSDB.java
View file

@ -53,7 +53,6 @@ import edu.cornell.mannlib.vitro.webapp.dao.VClassDao;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary; import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactorySDB.SDBDatasetMode; import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactorySDB.SDBDatasetMode;
import edu.cornell.mannlib.vitro.webapp.filestorage.model.ImageInfo; import edu.cornell.mannlib.vitro.webapp.filestorage.model.ImageInfo;
import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch;
public class IndividualSDB extends IndividualImpl implements Individual { public class IndividualSDB extends IndividualImpl implements Individual {
@ -876,22 +875,6 @@ public class IndividualSDB extends IndividualImpl implements Individual {
return false; return false;
} }
@Override
public boolean isMemberOfClassProhibitedFromSearch(ProhibitedFromSearch pfs) {
List<VClass> types = getVClasses(false);
Iterator<VClass> itr = types.iterator();
while(itr.hasNext()) {
String typeURI = itr.next().getURI();
if (pfs.isClassProhibitedFromSearch(typeURI)) {
return true;
}
}
return false;
}
/** /**
* Overriding the base method so that we can do the sorting by arbitrary property here. An * Overriding the base method so that we can do the sorting by arbitrary property here. An
* IndividualSDB has a reference back to the model; everything else is just a dumb bean (for now). * IndividualSDB has a reference back to the model; everything else is just a dumb bean (for now).

8
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/ModelContext.java
View file

@ -7,6 +7,8 @@ import javax.servlet.ServletContext;
import com.hp.hpl.jena.ontology.OntModel; import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.rdf.model.ModelChangedListener; import com.hp.hpl.jena.rdf.model.ModelChangedListener;
import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary;
public class ModelContext { public class ModelContext {
private static final String ONT_MODEL_SELECTOR = "ontModelSelector"; private static final String ONT_MODEL_SELECTOR = "ontModelSelector";
@ -106,4 +108,10 @@ public class ModelContext {
} }
public static OntModel getDisplayModel(ServletContext ctx){
return(OntModel) ctx.getAttribute( DisplayVocabulary.DISPLAY_ONT_MODEL );
}
public static void setDisplayModel(OntModel ontModel, ServletContext ctx){
ctx.setAttribute(DisplayVocabulary.DISPLAY_ONT_MODEL,ontModel);
}
} }

600
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/elements/DateTimeWithPrecision.java
View file

@ -1,600 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.elements;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.joda.time.DateTime;
import org.joda.time.format.ISODateTimeFormat;
import com.hp.hpl.jena.datatypes.xsd.XSDDatatype;
import com.hp.hpl.jena.rdf.model.Literal;
import com.hp.hpl.jena.rdf.model.ResourceFactory;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.FreemarkerConfiguration;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.EditConfiguration;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.EditSubmission;
import freemarker.template.Configuration;
/**
* This is intended to work in conjunction with a template to create the HTML for a
* datetime with precision and to convert the submitted parameters into
* varname -> Literal and varname -> URI maps.
*
* The variables that get passed to the template are defined in:
* DateTimeWithPrecision.getMapForTemplate()
*
* Two variables will be defined for the N3 edit graphs (These are NOT variables passed to FM templates):
* $fieldname.precision - URI of datetime precision
* $fieldname.value - DateTime literal
*
*/
public class DateTimeWithPrecision extends BaseEditElement {
String fieldName;
/**
* This is the minimum datetime precision that this element
* will accept. If the parameters submitted do not meet this
* requirement, then a validation error will be created.
*/
VitroVocabulary.Precision minimumPrecision;
/**
* This is the maximum precision that the form should
* allow the user to enter. This value is not used by
* DateTimeWithPrecision for validation, it is only passed
* to the template. This should be removed when it can be
* specified in a ftl file.
*
* This could be thought of as the maximum precision to display.
*/
VitroVocabulary.Precision displayRequiredLevel;
VitroVocabulary.Precision DEFAULT_MIN_PRECISION = VitroVocabulary.Precision.DAY;
VitroVocabulary.Precision DEFAULT_DISPLAY_LEVEL = VitroVocabulary.Precision.DAY;
VitroVocabulary.Precision[] precisions = VitroVocabulary.Precision.values();
protected static final String BLANK_SENTINEL = ">SUBMITTED VALUE WAS BLANK<";
public DateTimeWithPrecision(Field field) {
super(field);
fieldName = field.getName();
minimumPrecision = DEFAULT_MIN_PRECISION;
displayRequiredLevel = DEFAULT_DISPLAY_LEVEL;
}
public DateTimeWithPrecision(Field field, VitroVocabulary.Precision minimumPrecision){
this(field);
if( minimumPrecision != null )
this.minimumPrecision = minimumPrecision;
else
this.minimumPrecision = DEFAULT_MIN_PRECISION;
this.displayRequiredLevel = this.minimumPrecision;
}
//it would be nice to have only the version of the constructor that takes the enum
//but this is to quickly get the JSP configuration working.
public DateTimeWithPrecision(Field field, String minimumPrecisionURI, String displayRequiredLevelUri){
this(field);
this.minimumPrecision = toPrecision( minimumPrecisionURI);
if( this.minimumPrecision == null )
throw new IllegalArgumentException(minimumPrecisionURI
+" is not a valid precision for minimumPrecision, see VitroVocabulary.Precision");
this.displayRequiredLevel = toPrecision( displayRequiredLevelUri );
if( this.displayRequiredLevel == null )
throw new IllegalArgumentException(displayRequiredLevelUri
+" is not a valid precision for displayRequiredLevel, see VitroVocabulary.Precision");
// if( this.displayRequiredLevel.ordinal() < this.minimumPrecision.ordinal() ){
// throw new IllegalArgumentException("the display precision level " + this.displayRequiredLevel
// + " is less precise than the required minimum precision of " + this.minimumPrecision);
// }
}
private static final Log log = LogFactory.getLog(DateTimeWithPrecision.class);
protected String TEMPLATE_NAME = "dateTimeWithPrecision.ftl";
@Override
public String draw(String fieldName, EditConfiguration editConfig,
EditSubmission editSub, Configuration fmConfig) {
Map map = getMapForTemplate( editConfig, editSub);
return merge( fmConfig, TEMPLATE_NAME, map);
}
/**
* This produces a map for use in the template.
*/
protected Map getMapForTemplate(EditConfiguration editConfig, EditSubmission editSub) {
Map<String,Object>map = new HashMap<String,Object>();
//always need the fieldName, required precision, and constants
map.put("fieldName", fieldName);
addPrecisionConstants(map);
map.put("minimumPrecision", minimumPrecision.uri());
map.put("requiredLevel", displayRequiredLevel.uri());
String precisionUri = getPrecision(editConfig,editSub);
VitroVocabulary.Precision existingPrec = toPrecision(precisionUri);
if( precisionUri != null && !"".equals(precisionUri) && existingPrec == null ){
log.error("field " + fieldName + ": existing precision uri was " +
"'" + precisionUri + "' but could not convert to Precision object");
}
if( precisionUri == null || precisionUri.isEmpty() || existingPrec == null){
map.put("existingPrecision", "");
/* no precision so there should also be no datetime */
DateTime value = getTimeValue(editConfig,editSub);
if( value != null )
log.info("Unexpected state: Precision for " + fieldName
+ " was '" + precisionUri + "' but date time was " + value);
map.put("year", "");
map.put("month", "");
map.put("day", "");
map.put("hour", "");
map.put("minute", "");
map.put("second", "") ;
} else if( VitroVocabulary.Precision.NONE.uri().equals(precisionUri) ){
//bdc34: not sure what to do with the NONE precision
map.put("existingPrecision", precisionUri);
map.put("year", "");
map.put("month", "");
map.put("day", "");
map.put("hour", "");
map.put("minute", "");
map.put("second", "") ;
}else{
map.put("existingPrecision", precisionUri);
DateTime value = getTimeValue(editConfig,editSub);
/* This is the case where there is a precision so there should be a datetime */
if( value == null )
log.error("Field " + fieldName + " has precision " + precisionUri
+ " but the date time is " + value);
/* only put the values in the map for ones which are significant based on the precision */
if( existingPrec.ordinal() >= VitroVocabulary.Precision.SECOND.ordinal() )
map.put("second", Integer.toString(value.getSecondOfMinute() )) ;
else
map.put("second", "");
if( existingPrec.ordinal() >= VitroVocabulary.Precision.MINUTE.ordinal() )
map.put("minute", Integer.toString(value.getMinuteOfHour()) );
else
map.put("minute", "");
if( existingPrec.ordinal() >= VitroVocabulary.Precision.HOUR.ordinal() )
map.put("hour", Integer.toString(value.getHourOfDay()) );
else
map.put("hour", "");
if( existingPrec.ordinal() >= VitroVocabulary.Precision.DAY.ordinal() )
map.put("day", Integer.toString(value.getDayOfMonth()) );
else
map.put("day", "");
if( existingPrec.ordinal() >= VitroVocabulary.Precision.MONTH.ordinal() )
map.put("month", Integer.toString(value.getMonthOfYear()));
else
map.put("month", "");
if( existingPrec.ordinal() >= VitroVocabulary.Precision.YEAR.ordinal() )
map.put("year", Integer.toString(value.getYear()));
else
map.put("year", "");
}
return map;
}
/** Adds precisionURIs for use by the templates */
private void addPrecisionConstants(Map<String,Object> map){
Map<String,Object> constants = new HashMap<String,Object>();
for( VitroVocabulary.Precision pc: VitroVocabulary.Precision.values()){
constants.put(pc.name().toLowerCase(),pc.uri());
}
map.put("precisionConstants", constants);
}
/**
* Gets the currently set precision. May return null.
*/
private String getPrecision(EditConfiguration editConfig, EditSubmission editSub) {
if( editSub != null ){
String submittedPrecisionURI = editSub.getUrisFromForm().get( getPrecisionVariableName() );
if( submittedPrecisionURI != null ){
return submittedPrecisionURI;
}
}
String existingPrecisionURI = editConfig.getUrisInScope().get( getPrecisionVariableName() );
if( existingPrecisionURI != null ){
return existingPrecisionURI;
}else{
return null;
}
}
private DateTime getTimeValue(EditConfiguration editConfig, EditSubmission editSub) {
if( editSub != null ){
Literal submittedValue = editSub.getLiteralsFromForm().get( getValueVariableName() );
if( submittedValue != null )
return new DateTime( submittedValue.getLexicalForm() );
}
Literal dtValue = editConfig.getLiteralsInScope().get( getValueVariableName() );
if( dtValue != null ){
return new DateTime( dtValue.getLexicalForm() );
}else{
return null;
}
}
/**
* This gets the literals for a submitted form from the queryParmeters.
* It will only be called if getValidationErrors() doesn't return any errors.
*/
@Override
public Map<String, Literal> getLiterals(String fieldName,
EditConfiguration editConfig, Map<String, String[]> queryParameters) {
Map<String,Literal> literalMap = new HashMap<String,Literal>();
Literal datetime =getDateTime( queryParameters);
literalMap.put(fieldName+"-value", datetime);
return literalMap;
}
protected Literal getDateTime( Map<String, String[]> queryParameters ) {
String submittedPrec = BLANK_SENTINEL;
try {
submittedPrec = getSubmittedPrecision( queryParameters);
} catch (Exception e) {
log.error("could not get submitted precsion",e);
}
if( BLANK_SENTINEL.equals( submittedPrec ) )
return null;
Integer year = parseToInt(fieldName+"-year", queryParameters);
//this is the case where date has not been filled out at all.
if( year == null )
return null;
Integer month = parseToInt(fieldName+"-month", queryParameters);
if( month == null || month == 0 )
month = 1;
Integer day = parseToInt(fieldName+"-day", queryParameters);
if( day == null || day == 0 )
day = 1;
Integer hour = parseToInt(fieldName+"-hour", queryParameters);
if( hour == null )
hour = 0;
Integer minute = parseToInt(fieldName+"-minute", queryParameters);
if( minute == null )
minute = 0;
Integer second = parseToInt(fieldName+"-second", queryParameters);
if( second == null )
second = 0;
DateTime value = new DateTime(
year.intValue(),month.intValue(),day.intValue(),
hour.intValue(),minute.intValue(),second.intValue(),0/*millis*/
);
return ResourceFactory.createTypedLiteral(
ISODateTimeFormat.dateHourMinuteSecond().print(value), /*does not include timezone*/
XSDDatatype.XSDdateTime);
}
/**
* This gets the URIs for a submitted form from the queryParmeters.
* It will only be called if getValidationErrors() doesn't return any errors.
*/
@Override
public Map<String, String> getURIs(String fieldName,
EditConfiguration editConfig, Map<String, String[]> queryParameters) {
String precisionUri;
try {
precisionUri = getSubmittedPrecision( queryParameters);
} catch (Exception e) {
log.error("getURIs() should only be called on input that passed getValidationErrors()");
return Collections.emptyMap();
}
Map<String,String> uriMap = new HashMap<String,String>();
if( precisionUri != null )
uriMap.put(fieldName+"-precision", precisionUri);
return uriMap;
}
/**
* Precision is based on the values returned by the form. Throws an exception with
* the error message if the queryParameters cannot make a valid date/precision because
* there are values missing.
*/
protected String getSubmittedPrecision(Map<String, String[]> queryParameters) throws Exception {
Integer year = parseToInt(fieldName+"-year",queryParameters);
Integer month = parseToInt(fieldName+"-month",queryParameters);
Integer day = parseToInt(fieldName+"-day",queryParameters);
Integer hour = parseToInt(fieldName+"-hour",queryParameters);
Integer minute = parseToInt(fieldName+"-minute",queryParameters);
Integer second = parseToInt(fieldName+"-second",queryParameters);
Integer[] values = { year, month, day, hour, minute, second };
/* find the most significant date field that is null. */
int indexOfFirstNull= -1;
for(int i=0; i < values.length ; i++){
if( values[i] == null ){
indexOfFirstNull = i;
break;
}
}
/* the field wasn't filled out at all */
if( indexOfFirstNull == 0 )
//return VitroVocabulary.Precision.NONE.uri();
return BLANK_SENTINEL;
/* if they all had values then we have seconds precision */
if( indexOfFirstNull == -1 )
return VitroVocabulary.Precision.SECOND.uri();
/* check that there are no values after the most significant null field
* that are non-null. */
boolean nonNullAfterFirstNull=false;
for(int i=0; i < values.length ; i++){
if( i > indexOfFirstNull && values[i] != null ){
nonNullAfterFirstNull = true;
break;
}
}
if( nonNullAfterFirstNull )
throw new Exception("Invalid date-time value. When creating a date-time value, there cannot be gaps between any of the selected fields.");
else{
return precisions[ indexOfFirstNull ].uri();
}
}
@Override
public Map<String, String> getValidationMessages(String fieldName,
EditConfiguration editConfig, Map<String, String[]> queryParameters) {
Map<String,String> errorMsgMap = new HashMap<String,String>();
//check that any parameters we got are single values
String[] names = {"year","month","day","hour","minute","second", "precision"};
for( String name:names){
if ( !hasNoneOrSingle(fieldName+"-"+name, queryParameters))
errorMsgMap.put(fieldName+"-"+name, "must have only one value for " + name);
}
String precisionURI = null;
try{
precisionURI = getSubmittedPrecision( queryParameters);
}catch(Exception ex){
errorMsgMap.put(fieldName,ex.getMessage());
return errorMsgMap;
}
errorMsgMap.putAll(checkDate( precisionURI, queryParameters) );
return errorMsgMap;
}
/**
* This checks for invalid date times.
*/
final static String NON_INTEGER_YEAR = "must enter a valid year";
final static String NON_INTEGER_MONTH = "must enter a valid month";
final static String NON_INTEGER_DAY = "must enter a valid day";
final static String NON_INTEGER_HOUR = "must enter a valid hour";
final static String NON_INTEGER_MINUTE = "must enter a valid minute";
final static String NON_INTEGER_SECOND = "must enter a valid second";
private Map<String,String> checkDate( String precisionURI, Map<String, String[]> qp){
if( precisionURI == null )
return Collections.emptyMap();
Map<String,String> errors = new HashMap<String,String>();
Integer year,month,day,hour,minute,second;
//just check if the values for the precision parse to integers
if( precisionURI.equals(VitroVocabulary.Precision.YEAR.uri() ) ){
if( ! canParseToNumber(fieldName+"-year" ,qp))
errors.put(fieldName+"-year", NON_INTEGER_YEAR);
}else if( precisionURI.equals( VitroVocabulary.Precision.MONTH.uri() )){
if( ! canParseToNumber(fieldName+"-year" ,qp))
errors.put(fieldName+"-year", NON_INTEGER_YEAR);
if( ! canParseToNumber(fieldName+"-month" ,qp))
errors.put(fieldName+"-month", NON_INTEGER_MONTH);
}else if( precisionURI.equals( VitroVocabulary.Precision.DAY.uri() )){
if( ! canParseToNumber(fieldName+"-year" ,qp))
errors.put(fieldName+"-year", NON_INTEGER_YEAR);
if( ! canParseToNumber(fieldName+"-month" ,qp))
errors.put(fieldName+"-month", NON_INTEGER_MONTH);
if( ! canParseToNumber(fieldName+"-day" ,qp))
errors.put(fieldName+"-day", NON_INTEGER_DAY);
}else if( precisionURI.equals( VitroVocabulary.Precision.HOUR.uri() )){
if( ! canParseToNumber(fieldName+"-year" ,qp))
errors.put(fieldName+"-year", NON_INTEGER_YEAR);
if( ! canParseToNumber(fieldName+"-month" ,qp))
errors.put(fieldName+"-month", NON_INTEGER_MONTH);
if( ! canParseToNumber(fieldName+"-day" ,qp))
errors.put(fieldName+"-day", NON_INTEGER_DAY);
if( ! canParseToNumber(fieldName+"-hour" ,qp))
errors.put(fieldName+"-hour", NON_INTEGER_HOUR);
}else if( precisionURI.equals( VitroVocabulary.Precision.MINUTE.uri() )){
if( ! canParseToNumber(fieldName+"-year" ,qp))
errors.put(fieldName+"-year", NON_INTEGER_YEAR);
if( ! canParseToNumber(fieldName+"-month" ,qp))
errors.put(fieldName+"-month", NON_INTEGER_MONTH);
if( ! canParseToNumber(fieldName+"-day" ,qp))
errors.put(fieldName+"-day", NON_INTEGER_DAY);
if( ! canParseToNumber(fieldName+"-hour" ,qp))
errors.put(fieldName+"-hour", NON_INTEGER_HOUR);
if( ! canParseToNumber(fieldName+"-minute" ,qp))
errors.put(fieldName+"-minute", NON_INTEGER_HOUR);
}else if( precisionURI.equals( VitroVocabulary.Precision.SECOND.uri() )){
if( ! canParseToNumber(fieldName+"-year" ,qp))
errors.put(fieldName+"-year", NON_INTEGER_YEAR);
if( ! canParseToNumber(fieldName+"-month" ,qp))
errors.put(fieldName+"-month", NON_INTEGER_MONTH);
if( ! canParseToNumber(fieldName+"-day" ,qp))
errors.put(fieldName+"-day", NON_INTEGER_DAY);
if( ! canParseToNumber(fieldName+"-hour" ,qp))
errors.put(fieldName+"-hour", NON_INTEGER_HOUR);
if( ! canParseToNumber(fieldName+"-minute" ,qp))
errors.put(fieldName+"-minute", NON_INTEGER_HOUR);
if( ! canParseToNumber(fieldName+"-second" ,qp))
errors.put(fieldName+"-second", NON_INTEGER_SECOND);
}
//check if we can make a valid date with these integers
year = parseToInt(fieldName+"-year", qp);
if( year == null )
year = 1999;
month= parseToInt(fieldName+"-month", qp);
if(month == null )
month = 1;
day = parseToInt(fieldName+"-day", qp);
if( day == null )
day = 1;
hour = parseToInt(fieldName+"-hour", qp);
if( hour == null )
hour = 0;
minute = parseToInt(fieldName+"-minute",qp);
if( minute == null )
minute = 0;
second = parseToInt(fieldName+"-second", qp);
if( second == null )
second = 0;
//initialize to something so that we can be assured not to get
//system date dependent behavior
DateTime dateTime = new DateTime("1970-01-01T00:00:00Z");
try{
dateTime = dateTime.withYear(year);
}catch(IllegalArgumentException iae){
errors.put(fieldName+"-year", iae.getLocalizedMessage());
}
try{
dateTime = dateTime.withMonthOfYear(month);
}catch(IllegalArgumentException iae){
errors.put(fieldName+"-month", iae.getLocalizedMessage());
}
try{
dateTime = dateTime.withDayOfMonth(day);
}catch(IllegalArgumentException iae){
errors.put(fieldName+"-day", iae.getLocalizedMessage());
}
try{
dateTime = dateTime.withHourOfDay(hour);
}catch(IllegalArgumentException iae){
errors.put(fieldName+"-hour", iae.getLocalizedMessage());
}
try{
dateTime = dateTime.withSecondOfMinute(second);
}catch(IllegalArgumentException iae){
errors.put(fieldName+"-second", iae.getLocalizedMessage());
}
return errors;
}
private boolean fieldMatchesPattern( String fieldName, Map<String,String[]>queryParameters, Pattern pattern){
String[] varg = queryParameters.get(fieldName);
if( varg == null || varg.length != 1 || varg[0] == null)
return false;
String value = varg[0];
Matcher match = pattern.matcher(value);
return match.matches();
}
private boolean emptyOrBlank(String key,Map<String, String[]> queryParameters){
String[] vt = queryParameters.get(key);
return ( vt == null || vt.length ==0 || vt[0] == null || vt[0].length() == 0 );
}
private boolean canParseToNumber(String key,Map<String, String[]> queryParameters){
Integer out = null;
try{
String[] vt = queryParameters.get(key);
if( vt == null || vt.length ==0 || vt[0] == null)
return false;
else{
out = Integer.parseInt(vt[0]);
return true;
}
}catch(IndexOutOfBoundsException iex){
out = null;
}catch(NumberFormatException nfe){
out = null;
}catch(NullPointerException npe){
out = null;
}
return false;
}
private Integer parseToInt(String key,Map<String, String[]> queryParameters){
Integer out = null;
try{
String[] vt = queryParameters.get(key);
if( vt == null || vt.length ==0 || vt[0] == null)
out = null;
else
out = Integer.parseInt(vt[0]);
}catch(IndexOutOfBoundsException iex){
out = null;
}catch(NumberFormatException nfe){
out = null;
}catch(NullPointerException npe){
out = null;
}
return out;
}
public VitroVocabulary.Precision getRequiredMinimumPrecision() {
return minimumPrecision;
}
public void setRequiredMinimumPrecision(
VitroVocabulary.Precision requiredMinimumPrecision) {
this.minimumPrecision = requiredMinimumPrecision;
}
/* returns null if it cannot convert */
public static VitroVocabulary.Precision toPrecision(String precisionUri){
for( VitroVocabulary.Precision precision : VitroVocabulary.Precision.values()){
if( precision.uri().equals(precisionUri))
return precision;
}
return null;
}
public String getValueVariableName(){ return fieldName + "-value" ; }
public String getPrecisionVariableName(){ return fieldName + "-precision" ; }
}

1
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/BaseEditElementVTwo.java
View file

@ -9,6 +9,7 @@ import java.util.Map;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import freemarker.template.Configuration; import freemarker.template.Configuration;
import freemarker.template.Template; import freemarker.template.Template;
import freemarker.template.TemplateException; import freemarker.template.TemplateException;

1
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/BasicValidationVTwo.java
View file

@ -24,6 +24,7 @@ import com.hp.hpl.jena.rdf.model.ModelFactory;
import edu.cornell.mannlib.vitro.webapp.beans.Datatype; import edu.cornell.mannlib.vitro.webapp.beans.Datatype;
import edu.cornell.mannlib.vitro.webapp.dao.jena.DatatypeDaoJena; import edu.cornell.mannlib.vitro.webapp.dao.jena.DatatypeDaoJena;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactoryJena; import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactoryJena;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.EditConfiguration; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.EditConfiguration;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.EditSubmission; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.EditSubmission;

9
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/DateTimeIntervalValidationVTwo.java
View file

@ -4,8 +4,8 @@ package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo;
import java.util.Calendar; import java.util.Calendar;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map;
import java.util.List; import java.util.List;
import java.util.Map;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
@ -15,9 +15,6 @@ import com.hp.hpl.jena.rdf.model.Literal;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary; import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary.Precision; import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary.Precision;
import edu.cornell.mannlib.vitro.webapp.edit.elements.DateTimeWithPrecision;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.EditConfiguration;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.EditSubmission;
/* /*
* Assumption for date time interval validation: Only one start field/end field/and precision. * Assumption for date time interval validation: Only one start field/end field/and precision.
@ -133,9 +130,9 @@ public class DateTimeIntervalValidationVTwo implements N3ValidatorVTwo {
//Currently checks first precision str and then returns response //Currently checks first precision str and then returns response
if(precisionStr.size() > 0) { if(precisionStr.size() > 0) {
String precisionString = precisionStr.get(0); String precisionString = precisionStr.get(0);
VitroVocabulary.Precision precision = DateTimeWithPrecision.toPrecision( precisionString ); VitroVocabulary.Precision precision = DateTimeWithPrecisionVTwo.toPrecision( precisionString );
if( precision == null ) if( precision == null )
log.warn("cannot convert " + precisionStr + " to a precision"); log.debug("cannot convert " + precisionStr + " to a precision");
else else
return precision; return precision;
} else { } else {

5
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/DateTimeWithPrecisionVTwo.java
View file

@ -20,6 +20,7 @@ import com.hp.hpl.jena.rdf.model.ResourceFactory;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.FreemarkerConfiguration; import edu.cornell.mannlib.vitro.webapp.controller.freemarker.FreemarkerConfiguration;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary; import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.EditConfiguration; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.EditConfiguration;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.EditSubmission; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.EditSubmission;
@ -133,9 +134,11 @@ public class DateTimeWithPrecisionVTwo extends BaseEditElementVTwo {
VitroVocabulary.Precision existingPrec = toPrecision(precisionUri); VitroVocabulary.Precision existingPrec = toPrecision(precisionUri);
if( precisionUri != null && !"".equals(precisionUri) && existingPrec == null ){ if( precisionUri != null && !"".equals(precisionUri) && existingPrec == null ){
log.error("field " + getFieldName() + ": existing precision uri was " + if( ! BLANK_SENTINEL.equals( precisionUri )){
log.warn("field " + getFieldName() + ": existing precision uri was " +
"'" + precisionUri + "' but could not convert to Precision object"); "'" + precisionUri + "' but could not convert to Precision object");
} }
}
if( precisionUri == null || precisionUri.isEmpty() || existingPrec == null){ if( precisionUri == null || precisionUri.isEmpty() || existingPrec == null){
map.put("existingPrecision", ""); map.put("existingPrecision", "");

3
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/EditConfigurationUtils.java
View file

@ -20,6 +20,7 @@ import com.hp.hpl.jena.vocabulary.XSD;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary; import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory; import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.EditConfiguration; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.EditConfiguration;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.RdfLiteralHash; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.RdfLiteralHash;
@ -257,7 +258,7 @@ public class EditConfigurationUtils {
//Generate HTML for a specific field name given //Generate HTML for a specific field name given
public static String generateHTMLForElement(VitroRequest vreq, String fieldName, EditConfigurationVTwo editConfig) { public static String generateHTMLForElement(VitroRequest vreq, String fieldName, EditConfigurationVTwo editConfig) {
String html = ""; String html = "";
Configuration fmConfig = FreemarkerConfigurationLoader.getConfig(vreq, vreq.getSession().getServletContext()); Configuration fmConfig = FreemarkerConfigurationLoader.getConfig(vreq);
FieldVTwo field = editConfig == null ? null : editConfig.getField(fieldName); FieldVTwo field = editConfig == null ? null : editConfig.getField(fieldName);
MultiValueEditSubmission editSub = EditSubmissionUtils.getEditSubmissionFromSession(vreq.getSession(), editConfig); MultiValueEditSubmission editSub = EditSubmissionUtils.getEditSubmissionFromSession(vreq.getSession(), editConfig);

76
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/EditConfigurationVTwo.java
View file

@ -5,6 +5,7 @@ import java.text.SimpleDateFormat;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Calendar; import java.util.Calendar;
import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
@ -29,6 +30,7 @@ import com.hp.hpl.jena.rdf.model.ResourceFactory;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest; import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.DataPropertyDao; import edu.cornell.mannlib.vitro.webapp.dao.DataPropertyDao;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.ModelSelector; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.ModelSelector;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.StandardModelSelector; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.StandardModelSelector;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.StandardWDFSelector; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.StandardWDFSelector;
@ -429,11 +431,21 @@ public class EditConfigurationVTwo {
return EditConfigurationUtils.copy(n3Required); return EditConfigurationUtils.copy(n3Required);
} }
//TODO: can we use varargs here?
public void setN3Required(List<String> n3Required) { public void setN3Required(List<String> n3Required) {
this.n3Required = n3Required; this.n3Required = n3Required;
} }
public void setN3Required(String ... n3RequiredStrs){
this.n3Required = new ArrayList<String>(Arrays.asList( n3RequiredStrs )); //using ArrayList to allow list to be resized
}
//these methods allow strings to be added to the n3 required list and not just for the list to be set
public void addN3Required(List<String> n3RequiredInput) {
this.n3Required.addAll(n3RequiredInput);
}
public void addN3Required(String ... n3RequiredStrsInput) {
this.n3Required.addAll(Arrays.asList( n3RequiredStrsInput ));
}
/** return a copy of the value so that the configuration is not modified by external code. /** return a copy of the value so that the configuration is not modified by external code.
* @return * @return
*/ */
@ -445,6 +457,19 @@ public class EditConfigurationVTwo {
this.n3Optional = n3Optional; this.n3Optional = n3Optional;
} }
public void setN3Optional(String ... n3Strs){
this.n3Optional = new ArrayList<String>(Arrays.asList( n3Strs )); //using ArrayList to allow list to be resized
}
public void addN3Optional(List<String> n3Optional) {
this.n3Optional.addAll(n3Optional);
}
public void addN3Optional(String ... n3Strs){
this.n3Optional.addAll(Arrays.asList( n3Strs ));
}
public Map<String,String> getNewResources() { public Map<String,String> getNewResources() {
return newResources; return newResources;
} }
@ -453,6 +478,20 @@ public class EditConfigurationVTwo {
this.newResources = newResources; this.newResources = newResources;
} }
public void setNewResources(String ... strs){
if( strs == null || strs.length % 2 != 0 ){
throw new Error(" setNewResources() must have pairs of varName, prefix ");
}
Map<String,String> map = new HashMap<String,String>();
for( int i=0;i<strs.length;i=i+2 ){
map.put(strs[i],strs[i+1]);
}
this.newResources = map;
}
public List<String> getUrisOnform() { public List<String> getUrisOnform() {
return urisOnform; return urisOnform;
} }
@ -461,6 +500,19 @@ public class EditConfigurationVTwo {
this.urisOnform = urisOnform; this.urisOnform = urisOnform;
} }
public void setUrisOnForm(String ... strs){
this.urisOnform = new ArrayList<String>(Arrays.asList( strs )); //using ArrayList to allow resizing
}
//This doesn't overwrite or set but adds to existing list
public void addUrisOnForm(List<String> urisOnform) {
this.urisOnform.addAll(urisOnform);
}
public void addUrisOnForm(String ... strs){
this.urisOnform.addAll(Arrays.asList( strs ));
}
public void setFilesOnForm(List<String> filesOnForm){ public void setFilesOnForm(List<String> filesOnForm){
this.filesOnForm = filesOnForm; this.filesOnForm = filesOnForm;
} }
@ -477,6 +529,18 @@ public class EditConfigurationVTwo {
this.literalsOnForm = literalsOnForm; this.literalsOnForm = literalsOnForm;
} }
public void setLiteralsOnForm(String ... strs){
this.literalsOnForm = new ArrayList<String>(Arrays.asList( strs ));//using ArrayList to allow resizing
}
public void addLiteralsOnForm(List<String> literalsOnForm) {
this.literalsOnForm.addAll(literalsOnForm);
}
public void addLiteralsOnForm(String ... strs){
this.literalsOnForm.addAll(Arrays.asList( strs ));
}
public Map<String, List<String>> getUrisInScope() { public Map<String, List<String>> getUrisInScope() {
return urisInScope; return urisInScope;
} }
@ -1034,6 +1098,16 @@ public class EditConfigurationVTwo {
fields.put( field.getName(), field); fields.put( field.getName(), field);
} }
public void addFields(List<FieldVTwo> fields) {
if( fields != null )
{
for(FieldVTwo f: fields) {
this.addField(f);
}
}
}
@Override @Override
public String toString(){ public String toString(){
return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE); return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);

229
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/FieldVTwo.java
View file

@ -1,229 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.MultiValueEditSubmission;
public class FieldVTwo {
public enum OptionsType {
LITERALS,
HARDCODED_LITERALS,
STRINGS_VIA_DATATYPE_PROPERTY,
INDIVIDUALS_VIA_OBJECT_PROPERTY,
INDIVIDUALS_VIA_VCLASS,
CHILD_VCLASSES,
CHILD_VCLASSES_WITH_PARENT,
VCLASSGROUP,
FILE,
UNDEFINED,
DATETIME,
DATE,
TIME
};
public static String RDF_XML_LITERAL_URI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral";
private String name;
/**
* List of basic validators. See BaiscValidation.
*/
private List <String> validators = new ArrayList<String>();
/**
* What type of options is this?
*/
private OptionsType optionsType = OptionsType.UNDEFINED;
/**
* Special class to use for option type
*/
private Class customOptionType;
/**
* Used for building Options when OptionsType is INDIVIDUALS_VIA_OBJECT_PROPERTY
*/
private String predicateUri;
/**
* Used for building Options when OptionsType is INDIVIDUALS_VIA_VCLASS
*/
private String objectClassUri;
/**
* Used for holding the expected/required datatype of the predicate when the predicate is a datatype propertyl.
* this can be a explicit URI or a qname.
* example:
* "this is the literal"^^<http://someuri.com/v1.2#type23>
* or
* "this is the literal"^^someprefix:type23
*/
private String rangeDatatypeUri;
/**
* Used for holding the language of the literal when the predicate is a datatype property.
* This is the lang of the literal. lang strings must be: [a-z]+(-[a-z0-9]+)*
*/
private String rangeLang;
/**
* If this is a Select and it is of OptionsType LITERALS, these are the literals.
*/
private List<List<String>> literalOptions;
/**
* Property for special edit element.
*/
private EditElementVTwo editElement=null;;
/* *********************** Constructors ************************** */
public FieldVTwo() {}
private static String[] parameterNames = {"editElement","newResource","validators","optionsType","predicateUri","objectClassUri","rangeDatatypeUri","rangeLang","literalOptions","assertions"};
static{ Arrays.sort(parameterNames); }
public FieldVTwo setEditElement(EditElementVTwo editElement){
this.editElement = editElement;
if( editElement instanceof BaseEditElementVTwo)
((BaseEditElementVTwo) editElement).setField(this);
return this;
}
/* ****************** Getters and Setters ******************************* */
public String getName(){
return name;
}
public List <String> getValidators() {
return validators;
}
public FieldVTwo setValidators(List <String> v) {
validators = v;
return this;
}
public OptionsType getOptionsType() {
return optionsType;
}
public FieldVTwo setOptionsType(OptionsType ot) {
optionsType = ot;
return this;
}
public FieldVTwo setOptionsType(String s) {
setOptionsType( getOptionForString(s));
return this;
}
public static OptionsType getOptionForString(String s){
if( s== null || s.isEmpty() )
return OptionsType.UNDEFINED;
if ("LITERALS".equals(s)) {
return FieldVTwo.OptionsType.LITERALS;
} else if ("HARDCODED_LITERALS".equals(s)) {
return FieldVTwo.OptionsType.HARDCODED_LITERALS;
} else if ("STRINGS_VIA_DATATYPE_PROPERTY".equalsIgnoreCase(s)) {
return FieldVTwo.OptionsType.STRINGS_VIA_DATATYPE_PROPERTY;
} else if ("INDIVIDUALS_VIA_OBJECT_PROPERTY".equalsIgnoreCase(s)) {
return FieldVTwo.OptionsType.INDIVIDUALS_VIA_OBJECT_PROPERTY;
} else if ("INDIVIDUALS_VIA_VCLASS".equalsIgnoreCase(s)) {
return FieldVTwo.OptionsType.INDIVIDUALS_VIA_VCLASS;
} else if ("DATETIME".equalsIgnoreCase(s)) {
return FieldVTwo.OptionsType.DATETIME;
} else if ("CHILD_VCLASSES".equalsIgnoreCase(s)) {
return FieldVTwo.OptionsType.CHILD_VCLASSES;
} else if ("CHILD_VCLASSES_WITH_PARENT".equalsIgnoreCase(s)) {
return FieldVTwo.OptionsType.CHILD_VCLASSES_WITH_PARENT;
} else if ("VCLASSGROUP".equalsIgnoreCase(s)) {
return FieldVTwo.OptionsType.VCLASSGROUP;
} else if ("FILE".equalsIgnoreCase(s)) {
return FieldVTwo.OptionsType.FILE;
} else if ("DATE".equalsIgnoreCase(s)) {
return FieldVTwo.OptionsType.DATE;
} else if ("TIME".equalsIgnoreCase(s)) {
return FieldVTwo.OptionsType.TIME;
} else {
return FieldVTwo.OptionsType.UNDEFINED;
}
}
public String getPredicateUri() {
return predicateUri;
}
public FieldVTwo setPredicateUri(String s) {
predicateUri = s;
return this;
}
public String getObjectClassUri() {
return objectClassUri;
}
public FieldVTwo setObjectClassUri(String s) {
objectClassUri = s;
return this;
}
public String getRangeDatatypeUri() {
return rangeDatatypeUri;
}
public FieldVTwo setRangeDatatypeUri(String r) {
if( rangeLang != null && rangeLang.trim().length() > 0 )
throw new IllegalArgumentException("A Field object may not have both rangeDatatypeUri and rangeLanguage set");
rangeDatatypeUri = r;
return this;
}
public List <List<String>> getLiteralOptions() {
return literalOptions;
}
public FieldVTwo setLiteralOptions(List<List<String>> literalOptions) {
this.literalOptions = literalOptions;
return this;
}
public String getRangeLang() {
return rangeLang;
}
public FieldVTwo setRangeLang(String rangeLang) {
if( rangeDatatypeUri != null && rangeDatatypeUri.trim().length() > 0)
throw new IllegalArgumentException("A Field object may not have both rangeDatatypeUri and rangeLanguage set");
this.rangeLang = rangeLang;
return this;
}
public EditElementVTwo getEditElement(){
return editElement;
}
public FieldVTwo setName(String name){
this.name = name;
return this;
}
@Override
public String toString(){
return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);
}
}

2
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/MultiValueEditSubmission.java
View file

@ -33,7 +33,7 @@ import com.hp.hpl.jena.vocabulary.XSD;
import edu.cornell.mannlib.vitro.webapp.edit.EditLiteral; import edu.cornell.mannlib.vitro.webapp.edit.EditLiteral;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditElementVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditElementVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.FieldVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.BasicValidation; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.BasicValidation;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.N3Validator; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.N3Validator;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.EditN3Utils; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.EditN3Utils;

504
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/SelectListGeneratorVTwo.java
View file

@ -1,504 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.vocabulary.OWL;
import edu.cornell.mannlib.vitro.webapp.beans.DataProperty;
import edu.cornell.mannlib.vitro.webapp.beans.DataPropertyStatement;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.beans.ObjectProperty;
import edu.cornell.mannlib.vitro.webapp.beans.ObjectPropertyStatement;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.beans.VClassGroup;
import edu.cornell.mannlib.vitro.webapp.dao.DataPropertyDao;
import edu.cornell.mannlib.vitro.webapp.dao.DataPropertyStatementDao;
import edu.cornell.mannlib.vitro.webapp.dao.VClassDao;
import edu.cornell.mannlib.vitro.webapp.dao.VClassGroupDao;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactoryJena;
import edu.cornell.mannlib.vitro.webapp.dao.jena.pellet.PelletListener;
public class SelectListGeneratorVTwo {
static Log log = LogFactory.getLog(SelectListGeneratorVTwo.class);
public static Map<String,String> getOptions(
EditConfigurationVTwo editConfig,
String fieldName,
WebappDaoFactory wDaoFact){
if( editConfig == null ){
log.error( "fieldToSelectItemList() must be called with a non-null EditConfigurationVTwo ");
return Collections.EMPTY_MAP;
}
if( fieldName == null ){
log.error( "fieldToSelectItemList() must be called with a non-null fieldName");
return Collections.EMPTY_MAP;
}
FieldVTwo field = editConfig.getField(fieldName);
if (field==null) {
log.error("no field \""+fieldName+"\" found from editConfig in SelectListGenerator.getOptions()");
return Collections.EMPTY_MAP;
}
// now create an empty HashMap to populate and return
HashMap <String,String> optionsMap = new LinkedHashMap<String,String>();
// for debugging, keep a count of the number of options populated
int optionsCount=0;
FieldVTwo.OptionsType optionsType = field.getOptionsType();
String vclassUri = null;
switch (optionsType){
case HARDCODED_LITERALS: // originally not auto-sorted but sorted now, and empty values not removed or replaced
List<List<String>> hardcodedLiteralOptions = field.getLiteralOptions();
if (hardcodedLiteralOptions==null) {
log.error("no literalOptions List found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType HARDCODED_LITERALS specified");
return new HashMap <String,String>();
}
for(Object obj: ((Iterable)hardcodedLiteralOptions)){
List<String> literalPair = (List)obj;
String value=(String)literalPair.get(0);
if( value != null){ // allow empty string as a value
String label=(String)literalPair.get(1);
if (label!=null) {
optionsMap.put(value,label);
} else {
optionsMap.put(value, value);
}
++optionsCount;
}
}
break;
case LITERALS:
List<List<String>> literalOptions = field.getLiteralOptions();
if (literalOptions==null) {
log.error("no literalOptions List found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType LITERALS specified");
return new HashMap <String,String>();
}
for(Object obj: ((Iterable)literalOptions)){
List<String> literalPair = (List)obj;
String value=(String)literalPair.get(0);
if( value != null && value.trim().length() > 0){
String label=(String)literalPair.get(1);
if (label!=null && label.trim().length() > 0) {
optionsMap.put(value,label);
} else {
optionsMap.put(value, value);
}
++optionsCount;
}
}
break;
case STRINGS_VIA_DATATYPE_PROPERTY:
log.debug("processing Field \""+fieldName+"\" optionType as a datatype property predicateUri in SelectListGenerator.getOptions()");
String dataPropUri = field.getPredicateUri();
if (dataPropUri==null || dataPropUri.equals("")){
log.error("no predicate dataPropUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType STRINGS_VIA_DATATYPE_PROPERTY specified");
} else {
/* first test to see whether there's a default "leave blank" value specified with the literal options
String defaultOption=null;
if ((defaultOption=getDefaultOption(field))!=null) {
optionsMap.put(LEFT_BLANK, defaultOption);
} */
// now populate the options
log.debug("finding all choices for data property \""+dataPropUri+"\" in SelectListGenerator.getOptions()");
if( wDaoFact == null ) log.error("incoming WebappDaoFactory from request is null in SelectListGenerator.getOptions().");
DataPropertyStatementDao dpsDao = wDaoFact.getDataPropertyStatementDao();
DataPropertyDao dpDao = wDaoFact.getDataPropertyDao();
DataProperty dp = dpDao.getDataPropertyByURI(dataPropUri);
for (Iterator<DataPropertyStatement> i = dpsDao.getDataPropertyStatements(dp).iterator(); i.hasNext();) {
DataPropertyStatement dps = i.next();
if( dps != null ){
optionsMap.put(dps.getData().trim(),dps.getData().trim());
++optionsCount;
}
}
}
break;
case INDIVIDUALS_VIA_OBJECT_PROPERTY:
log.debug("processing Field \""+fieldName+"\" optionType as an object property predicateUri in SelectListGenerator.getOptions()");
String subjectUri = editConfig.getSubjectUri();
if (subjectUri==null || subjectUri.equals("")){
log.error("no subjectUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType INDIVIDUALS_VIA_OBJECTPROPERTY specified");
} else {
String predicateUri = field.getPredicateUri();
if (predicateUri==null || predicateUri.equals("")){
log.error("no predicateUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType INDIVIDUALS_VIA_OBJECTPROPERTY specified");
} else {
// first test to see whether there's a default "leave blank" value specified with the literal options
String defaultOption=null;
if ((defaultOption=getDefaultOption(field))!=null) {
optionsMap.put(LEFT_BLANK, defaultOption);
}
// now populate the options
log.debug("finding range individuals for subject \""+subjectUri+"\" and object property \""+predicateUri+"\" in SelectListGenerator.getOptions()");
if( wDaoFact == null ) log.error("could not get WebappDaoFactory from request in SelectListGenerator.getOptions().");
Individual subject = wDaoFact.getIndividualDao().getIndividualByURI(subjectUri);
if( subject == null ) log.error("could not get individual for subject uri "+subjectUri+" in SelectListGenerator.getOptions()");
ObjectProperty objProp = wDaoFact.getObjectPropertyDao().getObjectPropertyByURI(predicateUri);
if( objProp == null )
log.error("could not get object property for predicate "+predicateUri+" in SelectListGenerator.getOptions()");
List <VClass> vclasses = new ArrayList<VClass>();
vclasses = wDaoFact.getVClassDao().getVClassesForProperty(subject.getVClassURI(),predicateUri);
if( vclasses == null ){
log.error("no owl:Class found for predicate " + predicateUri );
break;
}
if( vclasses.size() == 0 )
log.error("no owl:Class found for predicate " + predicateUri );
List<Individual> individuals = new ArrayList<Individual>();
HashSet<String> uriSet = new HashSet<String>();
long startTime = System.currentTimeMillis();
for ( VClass vclass : vclasses){
for( Individual ind : wDaoFact.getIndividualDao().getIndividualsByVClassURI(vclass.getURI(),-1,-1)) {
if( !uriSet.contains(ind.getURI())) {
uriSet.add(ind.getURI());
individuals.add(ind);
}
}
}
List<ObjectPropertyStatement> stmts = subject.getObjectPropertyStatements();
if( stmts == null ) log.error("object properties for subject were null in SelectListGenerator.getOptions()");
individuals = removeIndividualsAlreadyInRange(individuals,stmts,predicateUri,editConfig.getObject());
//Collections.sort(individuals,new compareIndividualsByName());
for( Individual ind : individuals ){
String uri = ind.getURI();
if( uri != null ){
optionsMap.put(uri,ind.getName().trim());
++optionsCount;
}
}
}
}
break;
case INDIVIDUALS_VIA_VCLASS: //so we have a vclass URI
vclassUri = field.getObjectClassUri();
if (vclassUri==null || vclassUri.equals("")){
log.error("no vclassUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType INDIVIDUALS_VIA_VCLASS specified");
} else {
// first test to see whether there's a default "leave blank" value specified with the literal options
String defaultOption=null;
if ((defaultOption=getDefaultOption(field))!=null) {
optionsMap.put(LEFT_BLANK, defaultOption);
}
// now populate the options
if( wDaoFact == null ) log.error("could not get WebappDaoFactory from request in SelectListGenerator.getOptions().");
// if reasoning isn't available, we will also need to add
// individuals asserted in subclasses
boolean inferenceAvailable = false;
if (wDaoFact instanceof WebappDaoFactoryJena) {
PelletListener pl = ((WebappDaoFactoryJena) wDaoFact)
.getPelletListener();
if (pl != null && pl.isConsistent()
&& !pl.isInErrorState()
&& !pl.isReasoning()) {
inferenceAvailable = true;
}
}
VClass vclass = wDaoFact.getVClassDao().getVClassByURI( vclassUri );
if( vclass == null ) {
log.error("Cannot find owl:Class " + vclassUri + " in the model" );
optionsMap.put("", "Could not find class " + vclassUri);
}else{
Map<String, Individual> individualMap = new HashMap<String, Individual>();
for (Individual ind : wDaoFact.getIndividualDao().getIndividualsByVClassURI(vclass.getURI(),-1,-1)) {
if (ind.getURI() != null) {
individualMap.put(ind.getURI(), ind);
}
}
if (!inferenceAvailable) {
for (String subclassURI : wDaoFact.getVClassDao().getAllSubClassURIs(vclass.getURI())) {
for (Individual ind : wDaoFact.getIndividualDao().getIndividualsByVClassURI(subclassURI,-1,-1)) {
if (ind.getURI() != null) {
individualMap.put(ind.getURI(), ind);
}
}
}
}
List<Individual> individuals = new ArrayList<Individual>();
individuals.addAll(individualMap.values());
Collections.sort(individuals);
for (Individual ind : wDaoFact.getIndividualDao().getIndividualsByVClassURI(vclass.getURI(),-1,-1)) {
if (ind.getURI() != null) {
individualMap.put(ind.getURI(), ind);
}
}
if (!inferenceAvailable) {
for (String subclassURI : wDaoFact.getVClassDao().getAllSubClassURIs(vclass.getURI())) {
for (Individual ind : wDaoFact.getIndividualDao().getIndividualsByVClassURI(subclassURI,-1,-1)) {
if (ind.getURI() != null) {
individualMap.put(ind.getURI(), ind);
}
}
}
}
individuals.addAll(individualMap.values());
Collections.sort(individuals);
if (individuals.size()==0){
log.debug("No individuals of type "+vclass.getName()+" to add to pick list in SelectListGenerator.getOptions()");
optionsMap.put("", "No " + vclass.getName() + " found");
}else{
for( Individual ind : individuals ) {
String uri = ind.getURI();
if( uri != null ) {
optionsMap.put(uri,ind.getName().trim());
++optionsCount;
}
}
}
}
}
break;
case CHILD_VCLASSES: //so we have a vclass URI
vclassUri = field.getObjectClassUri();
if (vclassUri==null || vclassUri.equals("")){
log.error("no vclassUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType CHILD_VCLASSES specified");
} else {
// first test to see whether there's a default "leave blank" value specified with the literal options
String defaultOption=null;
if ((defaultOption=getDefaultOption(field))!=null) {
optionsMap.put(LEFT_BLANK, defaultOption);
}
// now populate the options
if( wDaoFact == null ) log.error("could not get WebappDaoFactory from request in SelectListGenerator.getOptions().");
VClassDao vclassDao = wDaoFact.getVClassDao();
List<String> subClassList = vclassDao.getAllSubClassURIs(vclassUri);
if( subClassList == null || subClassList.size()==0 ) {
log.debug("No subclasses of " + vclassUri + " found in the model so only default value from field's literalOptions will be used" );
} else {
for( String subClassUri : subClassList ) {
VClass subClass = vclassDao.getVClassByURI(subClassUri);
if( subClass != null && !OWL.Nothing.getURI().equals(subClassUri)) {
optionsMap.put(subClassUri,subClass.getName().trim());
++optionsCount;
}
}
}
}
break;
case CHILD_VCLASSES_WITH_PARENT: //so we have a vclass URI
vclassUri = field.getObjectClassUri();
if (vclassUri==null || vclassUri.equals("")){
log.error("no vclassUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType CHILD_VCLASSES specified");
} else {
// first test to see whether there's a default "leave blank" value specified with the literal options
String defaultOption=null;
if ((defaultOption=getDefaultOption(field))!=null) {
optionsMap.put(LEFT_BLANK, defaultOption);
}
// now populate the options
if( wDaoFact == null ) log.error("could not get WebappDaoFactory from request in SelectListGenerator.getOptions().");
VClassDao vclassDao = wDaoFact.getVClassDao();
List<String> subClassList = vclassDao.getAllSubClassURIs(vclassUri);
if( subClassList == null || subClassList.size()==0 ) {
log.debug("No subclasses of " + vclassUri + " found in the model so only default value from field's literalOptions will be used" );
} else {
for( String subClassUri : subClassList ) {
VClass subClass = vclassDao.getVClassByURI(subClassUri);
if( subClass != null && !OWL.Nothing.getURI().equals(subClassUri)) {
optionsMap.put(subClassUri,subClass.getName().trim());
++optionsCount;
}
}
optionsMap.put(vclassUri, "Other");
++optionsCount;
}
}
break;
case VCLASSGROUP:
String classGroupUri = field.getObjectClassUri(); // we're overloading this property to specify the classgroup
if (classGroupUri==null || classGroupUri.equals("")){
log.error("no classGroupUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType VCLASSGROUP specified");
} else {
// first test to see whether there's a default "leave blank" value specified with the literal options
String defaultOption=null;
if ((defaultOption=getDefaultOption(field))!=null) {
optionsMap.put(LEFT_BLANK, defaultOption);
}
// now populate the options
if( wDaoFact == null ) log.error("could not get WebappDaoFactory from request in SelectListGenerator.getOptions().");
VClassGroupDao vcgd = wDaoFact.getVClassGroupDao();
// Need to call this method to populate the classgroups - otherwise the classgroup class list is empty
List vClassGroups = vcgd.getPublicGroupsWithVClasses();
if (vClassGroups == null) {
log.error("No class groups found, so only default value from field's literalOptions will be used.");
} else {
VClassGroup vClassGroup = null;
for (Object o : vClassGroups) {
VClassGroup vcg = (VClassGroup) o;
if (vcg.getURI().equals(classGroupUri)) {
vClassGroup = vcg;
break;
}
}
if (vClassGroup == null) {
log.error("No class group with uri " + classGroupUri + "found, so only default value from field's literalOptions will be used.");
} else {
List<VClass> vClassList = vClassGroup.getVitroClassList();
if( vClassList == null || vClassList.size()==0 ) {
log.debug("No classes in class group " + classGroupUri + " found in the model, so only default value from field's literalOptions will be used" );
} else {
for( VClass vClass : vClassList ) {
String vClassUri = vClass.getURI();
if( vClass != null && !OWL.Nothing.getURI().equals(vClassUri)) {
optionsMap.put(vClassUri,vClass.getName().trim());
++optionsCount;
}
}
}
}
}
}
break;
case UNDEFINED :
log.error("optionsType \"UNDEFINED\" for Field \""+fieldName+"\" in SelectListGenerator.getOptions()");
break;
default: log.error("unknown optionsType "+optionsType.toString()+" for Field \""+fieldName+"\" in SelectListGenerator.getOptions()");
}
log.debug("added "+optionsCount+" options for field \""+fieldName+"\" in SelectListGenerator.getOptions()");
return optionsMap;
}
/**
* The default option is used when a option list is being auto
* generated from a VClass or an ObjectProperty. If there is an
* item in the literals item list then the name of it will be used
* as the text to display for an empty string value option.
*
* Having an option with an empty string for a Field that expects
* a URI will cause the form processing to assume that the field
* was left blank.
*
* @param field
* @return
*/
private static String getDefaultOption(FieldVTwo field) {
List <List<String>> defaultOptions = (List<List<String>>) field.getLiteralOptions();
if (defaultOptions!=null) {
for(Object obj: ((Iterable)defaultOptions)) {
List<String> pair = (List<String>)obj;
String value = pair.get(0);
String label = pair.get(1);
if( label != null && label.trim().length() > 0){
return label; // don't want to return a value
}
}
}
return null;
}
// copied from OptionsForPropertyTag.java in the thought that class may be deprecated
private static List<Individual> removeIndividualsAlreadyInRange(List<Individual> individuals,
List<ObjectPropertyStatement> stmts, String predicateUri, String objectUriBeingEdited){
log.debug("starting to check for duplicate range individuals in SelectListGenerator.removeIndividualsAlreadyInRange() ...");
HashSet<String> range = new HashSet<String>();
for(ObjectPropertyStatement ops : stmts){
if( ops.getPropertyURI().equals(predicateUri))
range.add( ops.getObjectURI() );
}
int removeCount=0;
ListIterator<Individual> it = individuals.listIterator();
while(it.hasNext()){
Individual ind = it.next();
if( range.contains( ind.getURI()) && !(ind.getURI().equals(objectUriBeingEdited)) ) {
it.remove();
++removeCount;
}
}
log.debug("removed "+removeCount+" duplicate range individuals");
return individuals;
}
//Methods to sort the options map
// from http://forum.java.sun.com/thread.jspa?threadID=639077&messageID=4250708
public static Map<String,String> getSortedMap(Map<String,String> hmap){
// first make temporary list of String arrays holding both the key and its corresponding value, so that the list can be sorted with a decent comparator
List<String[]> objectsToSort = new ArrayList<String[]>(hmap.size());
for (String key:hmap.keySet()) {
String[] x = new String[2];
x[0] = key;
x[1] = hmap.get(key);
objectsToSort.add(x);
}
Collections.sort(objectsToSort, new MapPairsComparator());
HashMap<String,String> map = new LinkedHashMap<String,String>(objectsToSort.size());
for (String[] pair:objectsToSort) {
map.put(pair[0],pair[1]);
}
return map;
}
private static class MapPairsComparator implements Comparator<String[]> {
public int compare (String[] s1, String[] s2) {
Collator collator = Collator.getInstance();
if (s2 == null) {
return 1;
} else if (s1 == null) {
return -1;
} else {
if ("".equals(s1[0])) {
return -1;
} else if ("".equals(s2[0])) {
return 1;
}
if (s2[1]==null) {
return 1;
} else if (s1[1] == null){
return -1;
} else {
return collator.compare(s1[1],s2[1]);
}
}
}
}
private static final String LEFT_BLANK = "";
}

83
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/fields/ChildVClassesOptions.java Normal file
View file

@ -0,0 +1,83 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.vocabulary.OWL;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.dao.VClassDao;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
public class ChildVClassesOptions implements FieldOptions {
private static final String LEFT_BLANK = "";
private String vclassUri;
private String defaultOptionLabel;
static Log log = LogFactory.getLog(ChildVClassesOptions.class);
public ChildVClassesOptions(String vclassUri) {
super();
this.vclassUri = vclassUri;
}
public ChildVClassesOptions setDefaultOptionLabel(String label){
this.defaultOptionLabel = label;
return this;
}
@Override
public Map<String, String> getOptions(
EditConfigurationVTwo editConfig,
String fieldName,
WebappDaoFactory wDaoFact) throws Exception{
// now create an empty HashMap to populate and return
HashMap <String,String> optionsMap = new LinkedHashMap<String,String>();
// for debugging, keep a count of the number of options populated
int optionsCount=0;
if (vclassUri==null || vclassUri.equals("")){
throw new Exception("no vclassUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType CHILD_VCLASSES specified");
} else {
// first test to see whether there's a default "leave blank" value specified with the literal options
if (defaultOptionLabel!=null) {
optionsMap.put(LEFT_BLANK, defaultOptionLabel);
}
// now populate the options
VClassDao vclassDao = wDaoFact.getVClassDao();
List<String> subClassList = vclassDao.getAllSubClassURIs(vclassUri);
if( subClassList == null || subClassList.size()==0 ) {
log.debug("No subclasses of " + vclassUri + " found in the model so only default value from field's literalOptions will be used" );
} else {
for( String subClassUri : subClassList ) {
VClass subClass = vclassDao.getVClassByURI(subClassUri);
if( subClass != null && !OWL.Nothing.getURI().equals(subClassUri)) {
optionsMap.put(subClassUri,subClass.getName().trim());
++optionsCount;
}
}
}
}
log.debug("added "+optionsCount+" options for field \""+fieldName+"\"");
return optionsMap;
}
public String getClassUri(){
return vclassUri;
}
}

66
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/fields/ChildVClassesWithParent.java Normal file
View file

@ -0,0 +1,66 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import com.hp.hpl.jena.vocabulary.OWL;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.dao.VClassDao;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
public class ChildVClassesWithParent implements FieldOptions {
private static final String LEFT_BLANK = "";
String fieldName;
String classUri;
String defaultOptionLabel = null;
public ChildVClassesWithParent(String classUri) throws Exception {
super();
if (classUri==null || classUri.equals(""))
throw new Exception ("vclassUri not set");
this.classUri = classUri;
}
public ChildVClassesWithParent setDefaultOption(String label){
this.defaultOptionLabel = label;
return this;
}
@Override
public Map<String, String> getOptions(
EditConfigurationVTwo editConfig,
String fieldName,
WebappDaoFactory wDaoFact) throws Exception {
HashMap <String,String> optionsMap = new LinkedHashMap<String,String>();
// first test to see whether there's a default "leave blank" value specified with the literal options
if ( ! StringUtils.isEmpty( defaultOptionLabel ) ){
optionsMap.put(LEFT_BLANK, defaultOptionLabel);
}
optionsMap.put(classUri, "Other");
VClassDao vclassDao = wDaoFact.getVClassDao();
List<String> subClassList = vclassDao.getAllSubClassURIs(classUri);
if (subClassList != null && subClassList.size() > 0) {
for (String subClassUri : subClassList) {
VClass subClass = vclassDao.getVClassByURI(subClassUri);
if (subClass != null && !OWL.Nothing.getURI().equals(subClassUri)) {
optionsMap.put(subClassUri, subClass.getName().trim());
}
}
}
return optionsMap;
}
}

76
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/fields/ConstantFieldOptions.java Normal file
View file

@ -0,0 +1,76 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
public class ConstantFieldOptions implements FieldOptions {
List<List<String>> options;
public ConstantFieldOptions(String ... optionPairs) throws Exception {
super();
if (optionPairs==null)
throw new Exception("Must specify option pairs in ConstantFieldOptions constructor");
if( optionPairs.length % 2 != 0)
throw new Exception("options must be in pairs of (value,lable)");
options = new ArrayList<List<String>>( optionPairs.length / 2 );
for(int i=0; i< optionPairs.length ; i=i+2){
List<String> pair = new ArrayList<String>(2);
pair.add(optionPairs[i]);
pair.add(optionPairs[i+1]);
options.add( pair );
}
}
public ConstantFieldOptions(String fieldName2,
List<List<String>> optionPairs) throws Exception {
for(List<String> literalPair: optionPairs ){
if( literalPair == null)
throw new Exception("no items in optionPairs may be null.");
if( literalPair.size() == 0 )
throw new Exception("no items in optionPairs may be empty lists.");
if( literalPair.size() > 2)
throw new Exception("no items in optionPairs may be lists longer than 2 items.");
}
options = optionPairs;
}
@Override
public Map<String, String> getOptions(
EditConfigurationVTwo editConfig,
String fieldName,
WebappDaoFactory wDaoFact) throws Exception {
// originally not auto-sorted but sorted now, and empty values not removed or replaced
HashMap <String,String> optionsMap = new LinkedHashMap<String,String>();
for(Object obj: ((Iterable)options)){
List<String> literalPair = (List)obj;
String value=(String)literalPair.get(0);
if( value != null){ // allow empty string as a value
String label=(String)literalPair.get(1);
if (label!=null) {
optionsMap.put(value,label);
} else {
optionsMap.put(value, value);
}
}
}
return optionsMap;
}
}

53
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/fields/FieldOptions.java Normal file
View file

@ -0,0 +1,53 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields;
import java.util.Map;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
/**
* Represents an object that can return a list of options
* for an HTML select list.
*
* @author bdc34
*
*/
public interface FieldOptions {
/**
* Any object that are needed to get the options should
* be passed in the constructor of the implementation.
*
* @return return a map of value->label for the options.
* Should never return null.
*
* @throws Exception
*/
public Map<String,String> getOptions(
EditConfigurationVTwo editConfig,
String fieldName,
WebappDaoFactory wDaoFact) throws Exception;
}
/*
* lic enum OptionsType {
LITERALS,x
HARDCODED_LITERALS,
STRINGS_VIA_DATATYPE_PROPERTY,
INDIVIDUALS_VIA_OBJECT_PROPERTY, x
INDIVIDUALS_VIA_VCLASS,
CHILD_VCLASSES, x
CHILD_VCLASSES_WITH_PARENT,
VCLASSGROUP,
FILE,
UNDEFINED, x
DATETIME,
DATE,
TIME
*/

141
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/fields/FieldVTwo.java Normal file
View file

@ -0,0 +1,141 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.BaseEditElementVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditElementVTwo;
public class FieldVTwo {
// public enum OptionsType {
// LITERALS,
// HARDCODED_LITERALS,
// STRINGS_VIA_DATATYPE_PROPERTY,
// INDIVIDUALS_VIA_OBJECT_PROPERTY,
// INDIVIDUALS_VIA_VCLASS,
// CHILD_VCLASSES,
// CHILD_VCLASSES_WITH_PARENT,
// VCLASSGROUP,
// FILE,
// UNDEFINED,
// DATETIME,
// DATE,
// TIME
// };
public static String RDF_XML_LITERAL_URI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral";
private String name;
/**
* List of basic validators. See BaiscValidation.
*/
private List <String> validators = new ArrayList<String>();
/** Object to get options from. */
private FieldOptions fieldOptions;
/**
* Used for holding the expected/required datatype of the predicate when the predicate is a datatype propertyl.
* this can be a explicit URI or a qname.
* example:
* "this is the literal"^^<http://someuri.com/v1.2#type23>
* or
* "this is the literal"^^someprefix:type23
*/
private String rangeDatatypeUri;
/**
* Used for holding the language of the literal when the predicate is a datatype property.
* This is the lang of the literal. lang strings must be: [a-z]+(-[a-z0-9]+)*
*/
private String rangeLang;
/**
* Property for special edit element.
*/
private EditElementVTwo editElement=null;;
/* *********************** Constructors ************************** */
public FieldVTwo() {}
//private static String[] parameterNames = {"editElement","newResource","validators","optionsType","predicateUri","objectClassUri","rangeDatatypeUri","rangeLang","literalOptions","assertions"};
//static{ Arrays.sort(parameterNames); }
/* ****************** Getters and Setters ******************************* */
public FieldVTwo setEditElement(EditElementVTwo editElement){
this.editElement = editElement;
if( editElement instanceof BaseEditElementVTwo)
((BaseEditElementVTwo) editElement).setField(this);
return this;
}
public String getName(){
return name;
}
public List <String> getValidators() {
return validators;
}
public FieldVTwo setValidators(List <String> v) {
validators = v;
return this;
}
public FieldVTwo setOptions( FieldOptions fopts){
this.fieldOptions = fopts;
return this;
}
public FieldOptions getFieldOptions(){
return this.fieldOptions;
}
public String getRangeDatatypeUri() {
return rangeDatatypeUri;
}
public FieldVTwo setRangeDatatypeUri(String r) {
if( rangeLang != null && rangeLang.trim().length() > 0 )
throw new IllegalArgumentException("A Field object may not have both rangeDatatypeUri and rangeLanguage set");
rangeDatatypeUri = r;
return this;
}
public String getRangeLang() {
return rangeLang;
}
public FieldVTwo setRangeLang(String rangeLang) {
if( rangeDatatypeUri != null && rangeDatatypeUri.trim().length() > 0)
throw new IllegalArgumentException("A Field object may not have both rangeDatatypeUri and rangeLanguage set");
this.rangeLang = rangeLang;
return this;
}
public EditElementVTwo getEditElement(){
return editElement;
}
public FieldVTwo setName(String name){
this.name = name;
return this;
}
@Override
public String toString(){
return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);
}
}

38
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/fields/IndividualsViaClassGroupOptions.java Normal file
View file

@ -0,0 +1,38 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields;
import java.util.Map;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
public class IndividualsViaClassGroupOptions implements FieldOptions {
String classGroupUri;
String defualtOptionLabel=null;
public IndividualsViaClassGroupOptions(String classGroupUri) {
super();
this.classGroupUri = classGroupUri;
}
public IndividualsViaClassGroupOptions setDefaultOptionLabel(String label){
defualtOptionLabel = label;
return this;
}
@Override
public Map<String, String> getOptions(
EditConfigurationVTwo editConfig,
String fieldName,
WebappDaoFactory wDaoFact) throws Exception {
throw new Error("not implemented");
}
public String getClassGroupUri(){
return classGroupUri;
}
}

125
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/fields/IndividualsViaObjectPropetyOptions.java Normal file
View file

@ -0,0 +1,125 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.beans.ObjectProperty;
import edu.cornell.mannlib.vitro.webapp.beans.ObjectPropertyStatement;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
public class IndividualsViaObjectPropetyOptions implements FieldOptions {
private static final String LEFT_BLANK = "";
private String subjectUri;
private String predicateUri;
private String objectUri;
private String defaultOptionLabel;
public IndividualsViaObjectPropetyOptions(String subjectUri,
String predicateUri, String objectUri) throws Exception {
super();
if (subjectUri == null || subjectUri.equals("")) {
throw new Exception("no subjectUri found for field ");
}
if (predicateUri == null || predicateUri.equals("")) {
throw new Exception("no predicateUri found for field ");
}
this.subjectUri = subjectUri;
this.predicateUri = predicateUri;
this.objectUri = objectUri;
}
public IndividualsViaObjectPropetyOptions setDefaultOptionLabel(String label){
this.defaultOptionLabel = label;
return this;
}
@Override
public Map<String, String> getOptions(
EditConfigurationVTwo editConfig,
String fieldName,
WebappDaoFactory wDaoFact) {
HashMap<String, String> optionsMap = new LinkedHashMap<String, String>();
int optionsCount = 0;
// first test to see whether there's a default "leave blank"
// value specified with the literal options
if ((defaultOptionLabel ) != null) {
optionsMap.put(LEFT_BLANK, defaultOptionLabel);
}
Individual subject = wDaoFact.getIndividualDao().getIndividualByURI(subjectUri);
ObjectProperty objProp = wDaoFact.getObjectPropertyDao().getObjectPropertyByURI(predicateUri);
List<VClass> vclasses = wDaoFact.getVClassDao().getVClassesForProperty(subject.getVClassURI(), predicateUri);
if (vclasses == null || vclasses.size() == 0) {
return optionsMap;
}
List<Individual> individuals = new ArrayList<Individual>();
HashSet<String> uriSet = new HashSet<String>();
for (VClass vclass : vclasses) {
List<Individual> inds = wDaoFact.getIndividualDao().getIndividualsByVClassURI(vclass.getURI(), -1, -1);
for (Individual ind : inds) {
if (!uriSet.contains(ind.getURI())) {
uriSet.add(ind.getURI());
individuals.add(ind);
}
}
}
List<ObjectPropertyStatement> stmts = subject.getObjectPropertyStatements();
individuals = removeIndividualsAlreadyInRange(
individuals, stmts, predicateUri, objectUri);
// Collections.sort(individuals,new compareIndividualsByName());
for (Individual ind : individuals) {
String uri = ind.getURI();
if (uri != null) {
optionsMap.put(uri, ind.getName().trim());
++optionsCount;
}
}
return optionsMap;
}
// copied from OptionsForPropertyTag.java in the thought that class may be deprecated
private static List<Individual> removeIndividualsAlreadyInRange(List<Individual> individuals,
List<ObjectPropertyStatement> stmts, String predicateUri, String objectUriBeingEdited){
HashSet<String> range = new HashSet<String>();
for(ObjectPropertyStatement ops : stmts){
if( ops.getPropertyURI().equals(predicateUri))
range.add( ops.getObjectURI() );
}
int removeCount=0;
ListIterator<Individual> it = individuals.listIterator();
while(it.hasNext()){
Individual ind = it.next();
if( range.contains( ind.getURI()) && !(ind.getURI().equals(objectUriBeingEdited)) ) {
it.remove();
++removeCount;
}
}
return individuals;
}
}

131
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/fields/IndividualsViaVClassOptions.java Normal file
View file

@ -0,0 +1,131 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.dao.IndividualDao;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactoryJena;
import edu.cornell.mannlib.vitro.webapp.dao.jena.pellet.PelletListener;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
public class IndividualsViaVClassOptions implements FieldOptions {
public static final String LEFT_BLANK = "";
private List<String> vclassURIs;
private String defaultOptionLabel;
public IndividualsViaVClassOptions(String ... vclassURIs) throws Exception {
super();
if (vclassURIs==null )
throw new Exception("vclassURIs must not be null or empty ");
this.vclassURIs = new ArrayList<String>(vclassURIs.length);
for(int i=0;i<vclassURIs.length;i++){
if( vclassURIs[i] != null && !vclassURIs[i].trim().isEmpty() )
this.vclassURIs.add(vclassURIs[i]);
}
}
public FieldOptions setDefaultOptionLabel(String label){
this.defaultOptionLabel = label;
return this;
}
@Override
public Map<String, String> getOptions(
EditConfigurationVTwo editConfig,
String fieldName,
WebappDaoFactory wDaoFact) throws Exception {
Map<String, Individual> individualMap = new HashMap<String, Individual>();
for( String vclassURI : this.vclassURIs){
individualMap.putAll( getIndividualsForClass( vclassURI, wDaoFact) );
}
//sort the individuals
List<Individual> individuals = new ArrayList<Individual>();
individuals.addAll(individualMap.values());
Collections.sort(individuals);
Map<String, String> optionsMap = new HashMap<String,String>();
if (defaultOptionLabel != null) {
optionsMap.put(LEFT_BLANK, defaultOptionLabel);
}
if (individuals.size() == 0) {
optionsMap.putAll( notFoundMsg() );
} else {
for (Individual ind : individuals) {
if (ind.getURI() != null) {
optionsMap.put(ind.getURI(), ind.getName().trim());
}
}
}
return optionsMap;
}
private Map<? extends String, ? extends String> notFoundMsg() {
String msg = "No individuals found for "+ (vclassURIs.size() > 1?"types":"type");
for( String uri : vclassURIs ){
msg += " " + uri;
}
return Collections.singletonMap("", msg);
}
protected Map<String,Individual> getIndividualsForClass(String vclassURI, WebappDaoFactory wDaoFact ){
Map<String, Individual> individualMap = new HashMap<String, Individual>();
IndividualDao indDao = wDaoFact.getIndividualDao();
List<Individual> indsForClass= indDao.getIndividualsByVClassURI(vclassURI, -1, -1);
for (Individual ind : indsForClass) {
if (ind.getURI() != null) {
individualMap.put(ind.getURI(), ind);
}
}
// if reasoning isn't available, we will also need to add
// individuals asserted in subclasses
individualMap.putAll( addWhenMissingInference(vclassURI, wDaoFact));
return individualMap;
}
protected boolean isReasoningAvailable( WebappDaoFactory wDaoFact){
boolean inferenceAvailable = false;
if (wDaoFact instanceof WebappDaoFactoryJena) {
PelletListener pl = ((WebappDaoFactoryJena) wDaoFact).getPelletListener();
if (pl != null && pl.isConsistent() && !pl.isInErrorState()
&& !pl.isReasoning()) {
inferenceAvailable = true;
}
}
return inferenceAvailable;
}
protected Map<String, Individual> addWhenMissingInference( String classUri , WebappDaoFactory wDaoFact ){
boolean inferenceAvailable = isReasoningAvailable(wDaoFact);
Map<String,Individual> individualMap = new HashMap<String,Individual>();
if ( !inferenceAvailable ) {
for (String subclassURI : wDaoFact.getVClassDao().getAllSubClassURIs(classUri)) {
for (Individual ind : wDaoFact.getIndividualDao().getIndividualsByVClassURI(subclassURI, -1, -1)) {
if (ind.getURI() != null) {
individualMap.put(ind.getURI(), ind);
}
}
}
}
return individualMap;
}
}

60
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/fields/RdfTypeOptions.java Normal file
View file

@ -0,0 +1,60 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
public class RdfTypeOptions implements FieldOptions {
String[] typeURIs;
public RdfTypeOptions(String ... superClassURIs)
throws Exception {
super();
if( superClassURIs == null )
throw new Exception("superClassURIs must be supplied "+
"to constructor.");
this.typeURIs = superClassURIs;
}
@Override
public Map<String, String> getOptions(
EditConfigurationVTwo editConfig,
String fieldName,
WebappDaoFactory wdf) {
Map<String,String> uriToLabel = new HashMap<String,String>();
for(int i=0;i<typeURIs.length; i++){
String uri = typeURIs[i];
VClass vc = wdf.getVClassDao().getVClassByURI( uri );
if( vc == null ){
uriToLabel.put(uri,uri);
continue;
}
uriToLabel.put(uri,vc.getPickListName());
List<String> subclassUris = wdf.getVClassDao().getAllSubClassURIs( uri );
if( subclassUris == null )
continue;
for( String subUri : subclassUris ){
VClass subVc = wdf.getVClassDao().getVClassByURI( subUri );
if( vc != null ){
uriToLabel.put(subUri,subVc.getPickListName());
}else{
uriToLabel.put(subUri,subUri);
}
}
}
return uriToLabel;
}
}

542
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/VTwo/fields/SelectListGeneratorVTwo.java Normal file
View file

@ -0,0 +1,542 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.vocabulary.OWL;
import edu.cornell.mannlib.vitro.webapp.beans.DataProperty;
import edu.cornell.mannlib.vitro.webapp.beans.DataPropertyStatement;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.beans.ObjectProperty;
import edu.cornell.mannlib.vitro.webapp.beans.ObjectPropertyStatement;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.beans.VClassGroup;
import edu.cornell.mannlib.vitro.webapp.dao.DataPropertyDao;
import edu.cornell.mannlib.vitro.webapp.dao.DataPropertyStatementDao;
import edu.cornell.mannlib.vitro.webapp.dao.VClassDao;
import edu.cornell.mannlib.vitro.webapp.dao.VClassGroupDao;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactoryJena;
import edu.cornell.mannlib.vitro.webapp.dao.jena.pellet.PelletListener;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
public class SelectListGeneratorVTwo {
static Log log = LogFactory.getLog(SelectListGeneratorVTwo.class);
public static Map<String,String> getOptions(
EditConfigurationVTwo editConfig,
String fieldName,
WebappDaoFactory wDaoFact){
if( editConfig == null ){
log.error( "fieldToSelectItemList() must be called with a non-null EditConfigurationVTwo ");
return Collections.EMPTY_MAP;
}
if( fieldName == null ){
log.error( "fieldToSelectItemList() must be called with a non-null fieldName");
return Collections.EMPTY_MAP;
}
FieldVTwo field = editConfig.getField(fieldName);
if (field==null) {
log.error("no field \""+fieldName+"\" found from editConfig.");
return Collections.EMPTY_MAP;
}
if( field.getFieldOptions() == null ){
log.error("cannot get options for a field if it has no FieldOption set.");
return Collections.EMPTY_MAP;
}
try {
return field.getFieldOptions().getOptions(editConfig,fieldName,wDaoFact);
} catch (Exception e) {
log.error("Error runing getFieldOptionis()",e);
return Collections.EMPTY_MAP;
}
}
// public static Map<String,String> getOptionsOldVersion(
// EditConfigurationVTwo editConfig,
// String fieldName,
// WebappDaoFactory wDaoFact){
//
//
// if( editConfig == null ){
// log.error( "fieldToSelectItemList() must be called with a non-null EditConfigurationVTwo ");
// return Collections.EMPTY_MAP;
// }
// if( fieldName == null ){
// log.error( "fieldToSelectItemList() must be called with a non-null fieldName");
// return Collections.EMPTY_MAP;
// }
//
// FieldVTwo field = editConfig.getField(fieldName);
// if (field==null) {
// log.error("no field \""+fieldName+"\" found from editConfig in SelectListGenerator.getOptions()");
// return Collections.EMPTY_MAP;
// }
//
// // now create an empty HashMap to populate and return
// HashMap <String,String> optionsMap = new LinkedHashMap<String,String>();
// // for debugging, keep a count of the number of options populated
// int optionsCount=0;
//
// FieldVTwo.OptionsType optionsType = field.getOptionsType();
// String vclassUri = null;
// switch (optionsType){
// case HARDCODED_LITERALS: // originally not auto-sorted but sorted now, and empty values not removed or replaced
// List<List<String>> hardcodedLiteralOptions = field.getLiteralOptions();
// if (hardcodedLiteralOptions==null) {
// log.error("no literalOptions List found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType HARDCODED_LITERALS specified");
// return new HashMap <String,String>();
// }
// for(Object obj: ((Iterable)hardcodedLiteralOptions)){
// List<String> literalPair = (List)obj;
// String value=(String)literalPair.get(0);
// if( value != null){ // allow empty string as a value
// String label=(String)literalPair.get(1);
// if (label!=null) {
// optionsMap.put(value,label);
// } else {
// optionsMap.put(value, value);
// }
// ++optionsCount;
// }
// }
// break;
// case LITERALS:
// List<List<String>> literalOptions = field.getLiteralOptions();
// if (literalOptions==null) {
// log.error("no literalOptions List found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType LITERALS specified");
// return new HashMap <String,String>();
// }
// for(Object obj: ((Iterable)literalOptions)){
// List<String> literalPair = (List)obj;
// String value=(String)literalPair.get(0);
// if( value != null && value.trim().length() > 0){
// String label=(String)literalPair.get(1);
// if (label!=null && label.trim().length() > 0) {
// optionsMap.put(value,label);
// } else {
// optionsMap.put(value, value);
// }
// ++optionsCount;
// }
// }
// break;
// case STRINGS_VIA_DATATYPE_PROPERTY:
// log.debug("processing Field \""+fieldName+"\" optionType as a datatype property predicateUri in SelectListGenerator.getOptions()");
// String dataPropUri = field.getPredicateUri();
// if (dataPropUri==null || dataPropUri.equals("")){
// log.error("no predicate dataPropUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType STRINGS_VIA_DATATYPE_PROPERTY specified");
// } else {
// /* first test to see whether there's a default "leave blank" value specified with the literal options
// String defaultOption=null;
// if ((defaultOption=getDefaultOption(field))!=null) {
// optionsMap.put(LEFT_BLANK, defaultOption);
// } */
// // now populate the options
// log.debug("finding all choices for data property \""+dataPropUri+"\" in SelectListGenerator.getOptions()");
//
// if( wDaoFact == null ) log.error("incoming WebappDaoFactory from request is null in SelectListGenerator.getOptions().");
//
// DataPropertyStatementDao dpsDao = wDaoFact.getDataPropertyStatementDao();
// DataPropertyDao dpDao = wDaoFact.getDataPropertyDao();
// DataProperty dp = dpDao.getDataPropertyByURI(dataPropUri);
// for (Iterator<DataPropertyStatement> i = dpsDao.getDataPropertyStatements(dp).iterator(); i.hasNext();) {
// DataPropertyStatement dps = i.next();
// if( dps != null ){
// optionsMap.put(dps.getData().trim(),dps.getData().trim());
// ++optionsCount;
// }
// }
// }
// break;
// case INDIVIDUALS_VIA_OBJECT_PROPERTY:
// log.debug("processing Field \""+fieldName+"\" optionType as an object property predicateUri in SelectListGenerator.getOptions()");
// String subjectUri = editConfig.getSubjectUri();
// if (subjectUri==null || subjectUri.equals("")){
// log.error("no subjectUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType INDIVIDUALS_VIA_OBJECTPROPERTY specified");
// } else {
// String predicateUri = field.getPredicateUri();
// if (predicateUri==null || predicateUri.equals("")){
// log.error("no predicateUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType INDIVIDUALS_VIA_OBJECTPROPERTY specified");
// } else {
// // first test to see whether there's a default "leave blank" value specified with the literal options
// String defaultOption=null;
// if ((defaultOption=getDefaultOption(field))!=null) {
// optionsMap.put(LEFT_BLANK, defaultOption);
// }
// // now populate the options
// log.debug("finding range individuals for subject \""+subjectUri+"\" and object property \""+predicateUri+"\" in SelectListGenerator.getOptions()");
//
// if( wDaoFact == null ) log.error("could not get WebappDaoFactory from request in SelectListGenerator.getOptions().");
//
// Individual subject = wDaoFact.getIndividualDao().getIndividualByURI(subjectUri);
// if( subject == null ) log.error("could not get individual for subject uri "+subjectUri+" in SelectListGenerator.getOptions()");
//
// ObjectProperty objProp = wDaoFact.getObjectPropertyDao().getObjectPropertyByURI(predicateUri);
// if( objProp == null )
// log.error("could not get object property for predicate "+predicateUri+" in SelectListGenerator.getOptions()");
//
// List <VClass> vclasses = new ArrayList<VClass>();
// vclasses = wDaoFact.getVClassDao().getVClassesForProperty(subject.getVClassURI(),predicateUri);
// if( vclasses == null ){
// log.error("no owl:Class found for predicate " + predicateUri );
// break;
// }
// if( vclasses.size() == 0 )
// log.error("no owl:Class found for predicate " + predicateUri );
//
// List<Individual> individuals = new ArrayList<Individual>();
// HashSet<String> uriSet = new HashSet<String>();
// long startTime = System.currentTimeMillis();
// for ( VClass vclass : vclasses){
// for( Individual ind : wDaoFact.getIndividualDao().getIndividualsByVClassURI(vclass.getURI(),-1,-1)) {
// if( !uriSet.contains(ind.getURI())) {
// uriSet.add(ind.getURI());
// individuals.add(ind);
// }
// }
// }
//
// List<ObjectPropertyStatement> stmts = subject.getObjectPropertyStatements();
// if( stmts == null ) log.error("object properties for subject were null in SelectListGenerator.getOptions()");
//
// individuals = removeIndividualsAlreadyInRange(individuals,stmts,predicateUri,editConfig.getObject());
// //Collections.sort(individuals,new compareIndividualsByName());
//
// for( Individual ind : individuals ){
// String uri = ind.getURI();
// if( uri != null ){
// optionsMap.put(uri,ind.getName().trim());
// ++optionsCount;
// }
// }
//
// }
// }
// break;
// case INDIVIDUALS_VIA_VCLASS: //so we have a vclass URI
// vclassUri = field.getObjectClassUri();
// if (vclassUri==null || vclassUri.equals("")){
// log.error("no vclassUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType INDIVIDUALS_VIA_VCLASS specified");
// } else {
// // first test to see whether there's a default "leave blank" value specified with the literal options
// String defaultOption=null;
// if ((defaultOption=getDefaultOption(field))!=null) {
// optionsMap.put(LEFT_BLANK, defaultOption);
// }
// // now populate the options
// if( wDaoFact == null ) log.error("could not get WebappDaoFactory from request in SelectListGenerator.getOptions().");
//
// // if reasoning isn't available, we will also need to add
// // individuals asserted in subclasses
// boolean inferenceAvailable = false;
// if (wDaoFact instanceof WebappDaoFactoryJena) {
// PelletListener pl = ((WebappDaoFactoryJena) wDaoFact)
// .getPelletListener();
// if (pl != null && pl.isConsistent()
// && !pl.isInErrorState()
// && !pl.isReasoning()) {
// inferenceAvailable = true;
// }
// }
//
// VClass vclass = wDaoFact.getVClassDao().getVClassByURI( vclassUri );
// if( vclass == null ) {
// log.error("Cannot find owl:Class " + vclassUri + " in the model" );
// optionsMap.put("", "Could not find class " + vclassUri);
// }else{
// Map<String, Individual> individualMap = new HashMap<String, Individual>();
//
// for (Individual ind : wDaoFact.getIndividualDao().getIndividualsByVClassURI(vclass.getURI(),-1,-1)) {
// if (ind.getURI() != null) {
// individualMap.put(ind.getURI(), ind);
// }
// }
//
// if (!inferenceAvailable) {
// for (String subclassURI : wDaoFact.getVClassDao().getAllSubClassURIs(vclass.getURI())) {
// for (Individual ind : wDaoFact.getIndividualDao().getIndividualsByVClassURI(subclassURI,-1,-1)) {
// if (ind.getURI() != null) {
// individualMap.put(ind.getURI(), ind);
// }
// }
// }
// }
//
// List<Individual> individuals = new ArrayList<Individual>();
// individuals.addAll(individualMap.values());
// Collections.sort(individuals);
//
// for (Individual ind : wDaoFact.getIndividualDao().getIndividualsByVClassURI(vclass.getURI(),-1,-1)) {
// if (ind.getURI() != null) {
// individualMap.put(ind.getURI(), ind);
// }
// }
//
// if (!inferenceAvailable) {
// for (String subclassURI : wDaoFact.getVClassDao().getAllSubClassURIs(vclass.getURI())) {
// for (Individual ind : wDaoFact.getIndividualDao().getIndividualsByVClassURI(subclassURI,-1,-1)) {
// if (ind.getURI() != null) {
// individualMap.put(ind.getURI(), ind);
// }
// }
// }
// }
//
// individuals.addAll(individualMap.values());
// Collections.sort(individuals);
//
// if (individuals.size()==0){
// log.debug("No individuals of type "+vclass.getName()+" to add to pick list in SelectListGenerator.getOptions()");
// optionsMap.put("", "No " + vclass.getName() + " found");
// }else{
// for( Individual ind : individuals ) {
// String uri = ind.getURI();
// if( uri != null ) {
// optionsMap.put(uri,ind.getName().trim());
// ++optionsCount;
// }
// }
// }
// }
// }
// break;
// case CHILD_VCLASSES: //so we have a vclass URI
// vclassUri = field.getObjectClassUri();
// if (vclassUri==null || vclassUri.equals("")){
// log.error("no vclassUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType CHILD_VCLASSES specified");
// } else {
// // first test to see whether there's a default "leave blank" value specified with the literal options
// String defaultOption=null;
// if ((defaultOption=getDefaultOption(field))!=null) {
// optionsMap.put(LEFT_BLANK, defaultOption);
// }
// // now populate the options
// if( wDaoFact == null ) log.error("could not get WebappDaoFactory from request in SelectListGenerator.getOptions().");
//
// VClassDao vclassDao = wDaoFact.getVClassDao();
// List<String> subClassList = vclassDao.getAllSubClassURIs(vclassUri);
// if( subClassList == null || subClassList.size()==0 ) {
// log.debug("No subclasses of " + vclassUri + " found in the model so only default value from field's literalOptions will be used" );
// } else {
// for( String subClassUri : subClassList ) {
// VClass subClass = vclassDao.getVClassByURI(subClassUri);
// if( subClass != null && !OWL.Nothing.getURI().equals(subClassUri)) {
// optionsMap.put(subClassUri,subClass.getName().trim());
// ++optionsCount;
// }
// }
// }
// }
// break;
//
// case CHILD_VCLASSES_WITH_PARENT: //so we have a vclass URI
// vclassUri = field.getObjectClassUri();
// if (vclassUri==null || vclassUri.equals("")){
// log.error("no vclassUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType CHILD_VCLASSES specified");
// } else {
// // first test to see whether there's a default "leave blank" value specified with the literal options
// String defaultOption=null;
// if ((defaultOption=getDefaultOption(field))!=null) {
// optionsMap.put(LEFT_BLANK, defaultOption);
// }
// // now populate the options
// if( wDaoFact == null ) log.error("could not get WebappDaoFactory from request in SelectListGenerator.getOptions().");
//
// VClassDao vclassDao = wDaoFact.getVClassDao();
// List<String> subClassList = vclassDao.getAllSubClassURIs(vclassUri);
// if( subClassList == null || subClassList.size()==0 ) {
// log.debug("No subclasses of " + vclassUri + " found in the model so only default value from field's literalOptions will be used" );
// } else {
// for( String subClassUri : subClassList ) {
// VClass subClass = vclassDao.getVClassByURI(subClassUri);
// if( subClass != null && !OWL.Nothing.getURI().equals(subClassUri)) {
// optionsMap.put(subClassUri,subClass.getName().trim());
// ++optionsCount;
// }
// }
// optionsMap.put(vclassUri, "Other");
// ++optionsCount;
// }
// }
// break;
//
// case VCLASSGROUP:
//
// String classGroupUri = field.getObjectClassUri(); // we're overloading this property to specify the classgroup
// if (classGroupUri==null || classGroupUri.equals("")){
// log.error("no classGroupUri found for field \""+fieldName+"\" in SelectListGenerator.getOptions() when OptionsType VCLASSGROUP specified");
// } else {
// // first test to see whether there's a default "leave blank" value specified with the literal options
// String defaultOption=null;
// if ((defaultOption=getDefaultOption(field))!=null) {
// optionsMap.put(LEFT_BLANK, defaultOption);
// }
// // now populate the options
// if( wDaoFact == null ) log.error("could not get WebappDaoFactory from request in SelectListGenerator.getOptions().");
//
// VClassGroupDao vcgd = wDaoFact.getVClassGroupDao();
//
// // Need to call this method to populate the classgroups - otherwise the classgroup class list is empty
// List vClassGroups = vcgd.getPublicGroupsWithVClasses();
//
// if (vClassGroups == null) {
// log.error("No class groups found, so only default value from field's literalOptions will be used.");
// } else {
// VClassGroup vClassGroup = null;
// for (Object o : vClassGroups) {
// VClassGroup vcg = (VClassGroup) o;
// if (vcg.getURI().equals(classGroupUri)) {
// vClassGroup = vcg;
// break;
// }
// }
// if (vClassGroup == null) {
// log.error("No class group with uri " + classGroupUri + "found, so only default value from field's literalOptions will be used.");
// } else {
// List<VClass> vClassList = vClassGroup.getVitroClassList();
//
// if( vClassList == null || vClassList.size()==0 ) {
// log.debug("No classes in class group " + classGroupUri + " found in the model, so only default value from field's literalOptions will be used" );
// } else {
// for( VClass vClass : vClassList ) {
// String vClassUri = vClass.getURI();
// if( vClass != null && !OWL.Nothing.getURI().equals(vClassUri)) {
// optionsMap.put(vClassUri,vClass.getName().trim());
// ++optionsCount;
// }
// }
// }
// }
// }
// }
// break;
//
// case UNDEFINED :
// log.error("optionsType \"UNDEFINED\" for Field \""+fieldName+"\" in SelectListGenerator.getOptions()");
// break;
// default: log.error("unknown optionsType "+optionsType.toString()+" for Field \""+fieldName+"\" in SelectListGenerator.getOptions()");
// }
// log.debug("added "+optionsCount+" options for field \""+fieldName+"\" in SelectListGenerator.getOptions()");
// return optionsMap;
// }
/**
* The default option is used when a option list is being auto
* generated from a VClass or an ObjectProperty. If there is an
* item in the literals item list then the name of it will be used
* as the text to display for an empty string value option.
*
* Having an option with an empty string for a Field that expects
* a URI will cause the form processing to assume that the field
* was left blank.
*
* @param field
* @return
*/
// private static String getDefaultOption(FieldVTwo field) {
// List <List<String>> defaultOptions = (List<List<String>>) field.getLiteralOptions();
// if (defaultOptions!=null) {
// for(Object obj: ((Iterable)defaultOptions)) {
// List<String> pair = (List<String>)obj;
// String value = pair.get(0);
// String label = pair.get(1);
// if( label != null && label.trim().length() > 0){
// return label; // don't want to return a value
// }
// }
// }
// return null;
// }
//
// copied from OptionsForPropertyTag.java in the thought that class may be deprecated
private static List<Individual> removeIndividualsAlreadyInRange(List<Individual> individuals,
List<ObjectPropertyStatement> stmts, String predicateUri, String objectUriBeingEdited){
log.debug("starting to check for duplicate range individuals in SelectListGenerator.removeIndividualsAlreadyInRange() ...");
HashSet<String> range = new HashSet<String>();
for(ObjectPropertyStatement ops : stmts){
if( ops.getPropertyURI().equals(predicateUri))
range.add( ops.getObjectURI() );
}
int removeCount=0;
ListIterator<Individual> it = individuals.listIterator();
while(it.hasNext()){
Individual ind = it.next();
if( range.contains( ind.getURI()) && !(ind.getURI().equals(objectUriBeingEdited)) ) {
it.remove();
++removeCount;
}
}
log.debug("removed "+removeCount+" duplicate range individuals");
return individuals;
}
//Methods to sort the options map
// from http://forum.java.sun.com/thread.jspa?threadID=639077&messageID=4250708
public static Map<String,String> getSortedMap(Map<String,String> hmap){
// first make temporary list of String arrays holding both the key and its corresponding value, so that the list can be sorted with a decent comparator
List<String[]> objectsToSort = new ArrayList<String[]>(hmap.size());
for (String key:hmap.keySet()) {
String[] x = new String[2];
x[0] = key;
x[1] = hmap.get(key);
objectsToSort.add(x);
}
Collections.sort(objectsToSort, new MapPairsComparator());
HashMap<String,String> map = new LinkedHashMap<String,String>(objectsToSort.size());
for (String[] pair:objectsToSort) {
map.put(pair[0],pair[1]);
}
return map;
}
private static class MapPairsComparator implements Comparator<String[]> {
public int compare (String[] s1, String[] s2) {
Collator collator = Collator.getInstance();
if (s2 == null) {
return 1;
} else if (s1 == null) {
return -1;
} else {
if ("".equals(s1[0])) {
return -1;
} else if ("".equals(s2[0])) {
return 1;
}
if (s2[1]==null) {
return 1;
} else if (s1[1] == null){
return -1;
} else {
return collator.compare(s1[1],s2[1]);
}
}
}
}
private static final String LEFT_BLANK = "";
}

2
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/generators/DateTimeIntervalFormGenerator.java
View file

@ -18,7 +18,7 @@ import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.DateTimeIntervalVali
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.DateTimeWithPrecisionVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.DateTimeWithPrecisionVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationUtils; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationUtils;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.FieldVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.utils.FrontEndEditingUtils; import edu.cornell.mannlib.vitro.webapp.utils.FrontEndEditingUtils;
import edu.cornell.mannlib.vitro.webapp.utils.FrontEndEditingUtils.EditMode; import edu.cornell.mannlib.vitro.webapp.utils.FrontEndEditingUtils.EditMode;
import edu.cornell.mannlib.vitro.webapp.utils.generators.EditModeUtils; import edu.cornell.mannlib.vitro.webapp.utils.generators.EditModeUtils;

2
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/generators/DateTimeValueFormGenerator.java
View file

@ -17,7 +17,7 @@ import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.DateTimeWithPrecisionVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.DateTimeWithPrecisionVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationUtils; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationUtils;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.FieldVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.utils.FrontEndEditingUtils; import edu.cornell.mannlib.vitro.webapp.utils.FrontEndEditingUtils;
import edu.cornell.mannlib.vitro.webapp.utils.FrontEndEditingUtils.EditMode; import edu.cornell.mannlib.vitro.webapp.utils.FrontEndEditingUtils.EditMode;
import edu.cornell.mannlib.vitro.webapp.utils.generators.EditModeUtils; import edu.cornell.mannlib.vitro.webapp.utils.generators.EditModeUtils;

51
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/generators/DefaultAddMissingIndividualFormGenerator.java
View file

@ -34,8 +34,8 @@ import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTw
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.RdfLiteralHash; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.RdfLiteralHash;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditN3GeneratorVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditN3GeneratorVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.SelectListGeneratorVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.FieldVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.SelectListGeneratorVTwo;
import edu.cornell.mannlib.vitro.webapp.web.MiscWebUtils; import edu.cornell.mannlib.vitro.webapp.web.MiscWebUtils;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors.DefaultAddMissingIndividualFormModelPreprocessor; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors.DefaultAddMissingIndividualFormModelPreprocessor;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.AntiXssValidation; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.AntiXssValidation;
@ -319,7 +319,17 @@ public class DefaultAddMissingIndividualFormGenerator implements EditConfigurati
private void setFields(EditConfigurationVTwo editConfiguration, VitroRequest vreq, String predicateUri) { private void setFields(EditConfigurationVTwo editConfiguration, VitroRequest vreq, String predicateUri) {
Map<String, FieldVTwo> fields = new HashMap<String, FieldVTwo>(); Map<String, FieldVTwo> fields = new HashMap<String, FieldVTwo>();
if(EditConfigurationUtils.isObjectProperty(EditConfigurationUtils.getPredicateUri(vreq), vreq)) { if(EditConfigurationUtils.isObjectProperty(EditConfigurationUtils.getPredicateUri(vreq), vreq)) {
fields = getObjectPropertyField(editConfiguration, vreq);
//make name field
FieldVTwo field = new FieldVTwo();
field.setName("name");
List<String> validators = new ArrayList<String>();
validators.add("nonempty");
field.setValidators(validators);
fields.put(field.getName(), field);
} else { } else {
log.error("Is not object property so fields not set"); log.error("Is not object property so fields not set");
} }
@ -327,11 +337,6 @@ public class DefaultAddMissingIndividualFormGenerator implements EditConfigurati
editConfiguration.setFields(fields); editConfiguration.setFields(fields);
} }
private String getRangeClassUri(VitroRequest vreq) { private String getRangeClassUri(VitroRequest vreq) {
Individual subject = EditConfigurationUtils.getSubjectIndividual(vreq); Individual subject = EditConfigurationUtils.getSubjectIndividual(vreq);
ObjectProperty prop = EditConfigurationUtils.getObjectProperty(vreq); ObjectProperty prop = EditConfigurationUtils.getObjectProperty(vreq);
@ -355,36 +360,6 @@ public class DefaultAddMissingIndividualFormGenerator implements EditConfigurati
return rangeClass.getURI(); return rangeClass.getURI();
} }
private Map<String, FieldVTwo> getObjectPropertyField(
EditConfigurationVTwo editConfiguration, VitroRequest vreq) {
Map<String, FieldVTwo> fields = new HashMap<String, FieldVTwo>();
FieldVTwo field = new FieldVTwo();
field.setName("name");
//queryForExisting is not being used anywhere in Field
List<String> validators = new ArrayList<String>();
validators.add("nonempty");
field.setValidators(validators);
//subjectUri and subjectClassUri are not being used in Field
field.setOptionsType("UNDEFINED");
//TODO:check why predicate uri is empty on original jsp
field.setPredicateUri("");
field.setObjectClassUri("");
field.setRangeDatatypeUri(null);
field.setRangeLang(null);
field.setLiteralOptions(new ArrayList<List<String>>());
fields.put(field.getName(), field);
return fields;
}
private void prepareForUpdate(VitroRequest vreq, HttpSession session, EditConfigurationVTwo editConfiguration) { private void prepareForUpdate(VitroRequest vreq, HttpSession session, EditConfigurationVTwo editConfiguration) {
//Here, retrieve model from //Here, retrieve model from
Model model = (Model) session.getServletContext().getAttribute("jenaOntModel"); Model model = (Model) session.getServletContext().getAttribute("jenaOntModel");

3
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/generators/DefaultDataPropertyFormGenerator.java
View file

@ -21,7 +21,7 @@ import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.edit.EditLiteral; import edu.cornell.mannlib.vitro.webapp.edit.EditLiteral;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationUtils; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationUtils;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.FieldVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors.DefaultDataPropEmptyField; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors.DefaultDataPropEmptyField;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.AntiXssValidation; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.AntiXssValidation;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.RdfLiteralHash; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.RdfLiteralHash;
@ -80,7 +80,6 @@ public class DefaultDataPropertyFormGenerator extends BaseEditConfigurationGener
FieldVTwo literalField = new FieldVTwo() FieldVTwo literalField = new FieldVTwo()
.setName( literalVar ) .setName( literalVar )
.setPredicateUri(predicateUri)
.setRangeDatatypeUri(rangeDatatypeUri); .setRangeDatatypeUri(rangeDatatypeUri);
editConfiguration.addField( literalField ); editConfiguration.addField( literalField );

4
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/generators/DefaultDeleteGenerator.java
View file

@ -33,8 +33,8 @@ import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTw
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.RdfLiteralHash; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.RdfLiteralHash;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditN3GeneratorVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditN3GeneratorVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.SelectListGeneratorVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.FieldVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.SelectListGeneratorVTwo;
import edu.cornell.mannlib.vitro.webapp.web.MiscWebUtils; import edu.cornell.mannlib.vitro.webapp.web.MiscWebUtils;
import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch; import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch;

129
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/generators/DefaultObjectPropertyFormGenerator.java
View file

@ -20,14 +20,15 @@ import com.hp.hpl.jena.rdf.model.Literal;
import com.hp.hpl.jena.rdf.model.Model; import com.hp.hpl.jena.rdf.model.Model;
import edu.cornell.mannlib.vitro.webapp.beans.DataProperty; import edu.cornell.mannlib.vitro.webapp.beans.DataProperty;
import edu.cornell.mannlib.vitro.webapp.beans.DataPropertyStatement;
import edu.cornell.mannlib.vitro.webapp.beans.Individual; import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.beans.ObjectProperty; import edu.cornell.mannlib.vitro.webapp.beans.ObjectProperty;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest; import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary; import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationUtils; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationUtils;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.FieldVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldOptions;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.IndividualsViaObjectPropetyOptions;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.AntiXssValidation; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.AntiXssValidation;
import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch; import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch;
@ -57,19 +58,23 @@ public class DefaultObjectPropertyFormGenerator implements EditConfigurationGene
} }
@Override @Override
public EditConfigurationVTwo getEditConfiguration(VitroRequest vreq, public EditConfigurationVTwo getEditConfiguration(VitroRequest vreq,
HttpSession session) { HttpSession session) throws Exception {
//Check if create new and return specific edit configuration from that generator. //Check if create new and return specific edit configuration from that generator.
if(DefaultAddMissingIndividualFormGenerator.isCreateNewIndividual(vreq, session)) { if(DefaultAddMissingIndividualFormGenerator.isCreateNewIndividual(vreq, session)) {
DefaultAddMissingIndividualFormGenerator generator = new DefaultAddMissingIndividualFormGenerator(); DefaultAddMissingIndividualFormGenerator generator = new DefaultAddMissingIndividualFormGenerator();
return generator.getEditConfiguration(vreq, session); return generator.getEditConfiguration(vreq, session);
} }
//TODO: Add a generator for delete: based on command being delete - propDelete.jsp //TODO: Add a generator for delete: based on command being delete - propDelete.jsp
//Generate a edit conf for the default object property form and return it. //Generate a edit configuration for the default object property form and return it.
//if(DefaultDeleteGenerator.isDelete( vreq,session)){
// return (new DefaultDeleteGenerator()).getEditConfiguration(vreq,session);
return getDefaultObjectEditConfiguration(vreq, session); return getDefaultObjectEditConfiguration(vreq, session);
} }
private EditConfigurationVTwo getDefaultObjectEditConfiguration(VitroRequest vreq, HttpSession session) { private EditConfigurationVTwo getDefaultObjectEditConfiguration(VitroRequest vreq, HttpSession session) throws Exception {
EditConfigurationVTwo editConfiguration = new EditConfigurationVTwo(); EditConfigurationVTwo editConfiguration = new EditConfigurationVTwo();
//process subject, predicate, object parameters //process subject, predicate, object parameters
@ -295,112 +300,19 @@ public class DefaultObjectPropertyFormGenerator implements EditConfigurationGene
} }
private void setFields(EditConfigurationVTwo editConfiguration, VitroRequest vreq, String predicateUri) { private void setFields(EditConfigurationVTwo editConfiguration, VitroRequest vreq, String predicateUri) throws Exception {
Map<String, FieldVTwo> fields = new HashMap<String, FieldVTwo>(); Map<String, FieldVTwo> fields = new HashMap<String, FieldVTwo>();
if(EditConfigurationUtils.isObjectProperty(EditConfigurationUtils.getPredicateUri(vreq), vreq)) { if(EditConfigurationUtils.isObjectProperty(EditConfigurationUtils.getPredicateUri(vreq), vreq)) {
fields = getObjectPropertyField(editConfiguration, vreq); fields = getObjectPropertyField(editConfiguration, vreq);
} else { } else {
fields = getDataPropertyField(editConfiguration, vreq); throw new Exception("DefaultObjectPropertyFormGenerator does not handle data properties.");
} }
editConfiguration.setFields(fields); editConfiguration.setFields(fields);
} }
private Map<String, FieldVTwo> getDataPropertyField(
EditConfigurationVTwo editConfiguration, VitroRequest vreq) {
Map<String, FieldVTwo> fields = new HashMap<String, FieldVTwo>();
FieldVTwo field = new FieldVTwo();
field.setName(dataLiteral);
//queryForExisting is not being used anywhere in Field
String rangeDatatypeUri = getRangeDatatypeUri(editConfiguration, vreq);
String rangeLang = getRangeLang(editConfiguration, vreq);
List<String> validators = new ArrayList<String>();
validators.add("datatype:" + rangeDatatypeUri);
field.setValidators(validators);
//subjectUri and subjectClassUri are not being used in Field
field.setOptionsType("LITERALS");
//why isn't predicate uri set for data properties?
field.setPredicateUri(null);
field.setObjectClassUri(null);
field.setRangeDatatypeUri(rangeDatatypeUri);
//have either range datatype uri or range lang
if(rangeDatatypeUri == null) {
field.setRangeLang(rangeLang);
}
field.setLiteralOptions(getLiteralOptions(editConfiguration, vreq));
fields.put(field.getName(), field);
return fields;
}
private List<List<String>> getLiteralOptions(
EditConfigurationVTwo editConfiguration, VitroRequest vreq) {
DataPropertyStatement dps =EditConfigurationUtils.getDataPropertyStatement(vreq, vreq.getSession(), dataHash, predicateUri);
List<List<String>> literalOptions = new ArrayList<List<String>>();
if(dps == null) {
log.debug("No incoming dataproperty statement attribute for property ; adding a new statement");
String rangeDatatypeUri = getRangeDatatypeUri(editConfiguration, vreq);
if(rangeDatatypeUri != null && rangeDatatypeUri.length() > 0) {
String defaultVal = defaultsForXSDtypes.get(rangeDatatypeUri);
List<String> defaultArray = new ArrayList<String>();
defaultArray.add(defaultVal);
literalOptions.add(defaultArray);
}
}
return literalOptions;
}
private String getRangeLang(EditConfigurationVTwo editConfiguration,
VitroRequest vreq) {
String rangeLang = null;
DataPropertyStatement dps =EditConfigurationUtils.getDataPropertyStatement(vreq, vreq.getSession(), dataHash, predicateUri);
if(dps != null) {
rangeLang = dps.getLanguage();
if( rangeLang == null ) {
log.debug("no language attribute on data property statement in DefaultDataPropertyFormGenerator");
}else{
log.debug("language attribute of ["+rangeLang+"] on data property statement in DefaultDataPropertyFormGenerator");
}
}
if( rangeLang != null && rangeLang.trim().length() == 0)
rangeLang = null;
return rangeLang;
}
private String getRangeDatatypeUri(EditConfigurationVTwo editConfiguration,
VitroRequest vreq) {
Individual subject = EditConfigurationUtils.getSubjectIndividual(vreq);
DataProperty prop = EditConfigurationUtils.getDataProperty(vreq);
//rangeDefaultJson goes into literalk options
//validations include dataype:rangedatatypeurijson
//rangeDatatypeUri is rangeDAttypeUriJson
//rangeLang = rangeLanJson
DataPropertyStatement dps =EditConfigurationUtils.getDataPropertyStatement(vreq, vreq.getSession(), dataHash, predicateUri);
String rangeDatatypeUri = vreq.getWebappDaoFactory().getDataPropertyDao().getRequiredDatatypeURI(subject, prop);
if( dps != null ){
rangeDatatypeUri = dps.getDatatypeURI();
if( rangeDatatypeUri == null ){
log.debug("no range datatype uri set on data property statement when property's range datatype is "+prop.getRangeDatatypeURI()+" in DefaultDataPropertyFormGenerator");
} else {
log.debug("range datatype uri of ["+rangeDatatypeUri+"] on data property statement in DefaultDataPropertyFormGenerator");
}
} else {
log.debug("No incoming dataproperty statement attribute for property "+prop.getPublicName()+"; adding a new statement");
}
if( rangeDatatypeUri != null && rangeDatatypeUri.trim().length() == 0)
rangeDatatypeUri = null;
return rangeDatatypeUri;
}
private Map<String, FieldVTwo> getObjectPropertyField( private Map<String, FieldVTwo> getObjectPropertyField(
EditConfigurationVTwo editConfiguration, VitroRequest vreq) { EditConfigurationVTwo editConfiguration, VitroRequest vreq) throws Exception {
Map<String, FieldVTwo> fields = new HashMap<String, FieldVTwo>(); Map<String, FieldVTwo> fields = new HashMap<String, FieldVTwo>();
FieldVTwo field = new FieldVTwo(); FieldVTwo field = new FieldVTwo();
field.setName("objectVar"); field.setName("objectVar");
@ -410,19 +322,12 @@ public class DefaultObjectPropertyFormGenerator implements EditConfigurationGene
validators.add("nonempty"); validators.add("nonempty");
field.setValidators(validators); field.setValidators(validators);
//subjectUri and subjectClassUri are not being used in Field field.setOptions( new IndividualsViaObjectPropetyOptions(
subjectUri,
field.setOptionsType("INDIVIDUALS_VIA_OBJECT_PROPERTY"); predicateUri,
field.setPredicateUri(predicateUri); objectUri));
field.setObjectClassUri(null);
field.setRangeDatatypeUri(null);
field.setRangeLang(null);
field.setLiteralOptions(new ArrayList<List<String>>());
fields.put(field.getName(), field); fields.put(field.getName(), field);
return fields; return fields;

2
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/generators/EditConfigurationGenerator.java
View file

@ -8,5 +8,5 @@ import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
public interface EditConfigurationGenerator { public interface EditConfigurationGenerator {
public EditConfigurationVTwo getEditConfiguration( VitroRequest vreq, HttpSession session ); public EditConfigurationVTwo getEditConfiguration( VitroRequest vreq, HttpSession session ) throws Exception;
} }

313
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/generators/ManagePageGenerator.java Normal file
View file

@ -0,0 +1,313 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.generators;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpSession;
import com.hp.hpl.jena.ontology.OntModel;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationUtils;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors.ManagePagePreprocessor;
import edu.cornell.mannlib.vitro.webapp.utils.dataGetter.DataGetterUtils;
import edu.cornell.mannlib.vitro.webapp.utils.menuManagement.MenuManagementDataUtils;
/**
* Generates the form for adding and editing a page in the display model.
*
*/
public class ManagePageGenerator extends BaseEditConfigurationGenerator implements EditConfigurationGenerator{
private String template = "pageManagement.ftl";
public static final String defaultDisplayNs = DisplayVocabulary.NAMESPACE.getURI() + "n";
@Override
public EditConfigurationVTwo getEditConfiguration( VitroRequest vreq, HttpSession session) {
EditConfigurationVTwo conf = new EditConfigurationVTwo();
conf.setTemplate(template);
//get editkey and url of form
initBasics(conf, vreq);
initPropertyParameters(vreq, session, conf);
//if object uri exists, sets object URI
initObjectPropForm(conf, vreq);
//Depending on whether this is a new individual to be created or editing
//an existing one, the var names will differ
setVarNames(conf);
//Set N3 required and optional
setN3Required(conf);
setN3Optional(conf);
//Designate new resources if any exist
setNewResources(conf);
//Add sparql queries
setSparqlQueries(conf);
// In scope
setUrisAndLiteralsInScope(conf, vreq);
// on Form
setUrisAndLiteralsOnForm(conf, vreq);
//Set the fields
setFields(conf);
//Adding additional data, specifically edit mode
addFormSpecificData(conf, vreq);
//Add preprocessor
conf.addEditSubmissionPreprocessor(new ManagePagePreprocessor(conf));
//Prepare
prepare(vreq, conf);
return conf ;
}
private void setUrisAndLiteralsOnForm(EditConfigurationVTwo conf,
VitroRequest vreq) {
conf.setUrisOnForm(new String[]{"page", "menuItem"}); //new resources: should this be on form for new - should be for existing
conf.setLiteralsOnForm(new String[]{"pageName", "prettyUrl", "menuPosition", "menuLinkText", "customTemplate", "pageContentUnit"}); //page content unit = data getter JSON object
}
private void setUrisAndLiteralsInScope(EditConfigurationVTwo conf,
VitroRequest vreq) {
//URIs
conf.addUrisInScope(conf.getVarNameForSubject(),
Arrays.asList(new String[]{conf.getSubjectUri()}));
conf.addUrisInScope(conf.getVarNameForPredicate(),
Arrays.asList(new String[]{conf.getPredicateUri()}));
}
private void setN3Optional(EditConfigurationVTwo conf) {
//body template is not required, and a given page may or may not be a menu item, but should linked to menu if menu item
conf.setN3Optional(new ArrayList<String>(Arrays.asList(prefixes + pageBodyTemplateN3,
prefixes + menuItemN3 + menuN3)));
}
private void setN3Required(EditConfigurationVTwo conf) {
conf.setN3Required(new ArrayList<String>(Arrays.asList(prefixes + pageN3)));
}
private void setFields(EditConfigurationVTwo conf) {
//Required fields for page include: Page title, page URL Mapping
//Data getter fields will be dealt with in preprocessor/util classes
//Optional fields for page include body template
//required, therefore nonempty
FieldVTwo titleField = new FieldVTwo().setName("pageName").
setValidators(Arrays.asList("nonempty"));
conf.addField(titleField);
FieldVTwo urlField = new FieldVTwo().setName("prettyUrl").setValidators(Arrays.asList("nonempty"));
conf.addField(urlField);
//optional: body template
FieldVTwo bodyTemplateField = new FieldVTwo().setName("customTemplate");
conf.addField(bodyTemplateField);
//For menu item, these are optional b/c they depend on menu item
FieldVTwo menuItemLinkTextField = new FieldVTwo().setName("menuLinkText");
conf.addField(menuItemLinkTextField);
FieldVTwo menuItemPositionField = new FieldVTwo().setName("menuPosition");
conf.addField(menuItemPositionField);
//The actual page content information is stored in this field, and then
//interpreted using the preprocessor
FieldVTwo pageContentUnitField = new FieldVTwo().setName("pageContentUnit");
conf.addField(pageContentUnitField);
//For existing values, will need to include fields here
}
private void setVarNames(EditConfigurationVTwo conf) {
if(conf.getSubjectUri() != null) {
conf.setVarNameForSubject("page");
conf.setVarNameForPredicate("predicate");
} else {
conf.setVarNameForSubject("subjectNotUsed");
conf.setVarNameForPredicate("predicateNotUsed");
}
}
//overriding
@Override
void initPropertyParameters(VitroRequest vreq, HttpSession session, EditConfigurationVTwo editConfiguration) {
String subjectUri = EditConfigurationUtils.getSubjectUri(vreq);
String predicateUri = EditConfigurationUtils.getPredicateUri(vreq);
//For the case of a new page
if(subjectUri == null) {
//Once added, return to pageList
editConfiguration.setUrlToReturnTo("/pageList");
editConfiguration.setEntityToReturnTo("?page");
editConfiguration.setPredicateUri(predicateUri);
} else {
//For the case of an existing page
//Page title pageName or page hasDataGetter dataGetter
editConfiguration.setUrlPatternToReturnTo("/individual");
editConfiguration.setEntityToReturnTo(subjectUri);
}
editConfiguration.setSubjectUri(subjectUri);
editConfiguration.setPredicateUri(predicateUri);
}
//also overriding
@Override
void prepare(VitroRequest vreq, EditConfigurationVTwo editConfig) {
//setup the model selectors for query, write and display models on editConfig
//Double-check if this will even work with over-written model in the case of display model?
setupModelSelectorsFromVitroRequest(vreq, editConfig);
OntModel queryModel = (OntModel)vreq.getAttribute("jenaOntModel");
if (editConfig.getSubjectUri() != null) {
editConfig.prepareForObjPropUpdate(queryModel);
}
else{
//if no subject uri, this is creating a new page
editConfig.prepareForNonUpdate(queryModel);
}
}
//In the case where this is a new page, need to ensure page gets a new
private void setNewResources(EditConfigurationVTwo conf) {
//null makes default namespace be triggered
conf.addNewResource("page", defaultDisplayNs);
conf.addNewResource("menuItem", defaultDisplayNs);
}
//This is for various items
private void setSparqlQueries(EditConfigurationVTwo editConfiguration) {
//Sparql queries defining retrieval of literals etc.
editConfiguration.setSparqlForAdditionalLiteralsInScope(new HashMap<String, String>());
Map<String, String> urisInScope = new HashMap<String, String>();
editConfiguration.setSparqlForAdditionalUrisInScope(urisInScope);
editConfiguration.setSparqlForExistingLiterals(generateSparqlForExistingLiterals());
editConfiguration.setSparqlForExistingUris(generateSparqlForExistingUris());
}
//Get page uri for object
private HashMap<String, String> generateSparqlForExistingUris() {
HashMap<String, String> map = new HashMap<String, String>();
return map;
}
private HashMap<String, String> generateSparqlForExistingLiterals() {
HashMap<String, String> map = new HashMap<String, String>();
return map;
}
//Form specific data
//In this case, need to get all the different data getter TYPES and labels
//Also need to pass back the map for the options presented to the user
//which is different from the above
//Maybe mapping where it does exist? I.e. sparql query from drop-down IS sparql query data getter
//Class group is hard-coded to class group but otherwise it can be changed
//Based on circumstances - specifically internal class data getter
//Need to get the hash for data getter to label TO the form so
//that can then be read by javascript?
//Also pass back current menu position?
public void addFormSpecificData(EditConfigurationVTwo editConfiguration, VitroRequest vreq) {
HashMap<String, Object> formSpecificData = new HashMap<String, Object>();
//Get options for user: label to data getter type
//For every type of page, will need some "always required" data
addRequiredPageData(vreq, formSpecificData);
//For a new page, we will need to add the following data
addNewPageData(vreq, formSpecificData);
editConfiguration.setFormSpecificData(formSpecificData);
}
private String getTemplate(EditConfigurationVTwo editConfiguration) {
String returnTemplate = "default";
if(editConfiguration.getSubjectUri() != null) {
//Then template is EXISTING template
//TODO: Get existing template value for page
}
return returnTemplate;
}
private void addRequiredPageData(VitroRequest vreq, Map<String, Object> data) {
MenuManagementDataUtils.includeRequiredSystemData(vreq.getSession().getServletContext(), data);
}
private void addNewPageData(VitroRequest vreq, Map<String, Object> data) {
data.put("title", "Add Menu Item");
data.put("menuAction", "Add");
//Generate empty values for fields
data.put("menuItem", "");
data.put("pageName", "");
data.put("prettyUrl", "");
data.put("associatedPage", "");
data.put("associatedPageURI", "");
data.put("classGroup", new ArrayList<String>());
//not a page already assigned a class group
data.put("isClassGroupPage", false);
data.put("includeAllClasses", false);
data.put("classGroups", DataGetterUtils.getClassGroups(vreq.getSession().getServletContext()));
data.put("selectedTemplateType", "default");
//defaults to regular class group page
}
//N3 strings
//For new or existing page
final static String prefixes = "@prefix display: <http://vitro.mannlib.cornell.edu/ontologies/display/1.1#> . \n" +
"@prefix rdfs:<http://www.w3.org/2000/01/rdf-schema#> . \n";
final static String pageN3 = "?page a display:Page ; \n" +
"display:title ?pageName ;\n" +
"display:urlMapping ?prettyUrl .";
//"display:hasDataGetter ?pageDataGetter .";
//A page may also require a body template so we can get that here as well
//That would be optional
final static String pageBodyTemplateN3 = "?page display:requiresBodyTemplate ?customTemplate .";
//Menu position is added dynamically at end by default and can be changed on reordering page
final static String menuItemN3 = "?menuItem a display:NavigationElement ; \n" +
"display:menuPosition ?menuPosition; \n" +
"display:linkText ?menuLinkText; \n" +
"display:toPage ?page .";
//We define n3 here from default menu item up through page, but data getters are added dyamically
//so will be dealt with in the preprocessor
final static String menuN3 = "display:DefaultMenu display:hasElement ?menuItem .";
//These are public static methods that can be used in the preprocessor
public final static String getDataGetterN3(String dataGetterVar) {
return prefixes + "?page display:hasDataGetter " + dataGetterVar + ".";
}
}

6
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/generators/MenuEditingFormGenerator.java
View file

@ -29,8 +29,8 @@ import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory; import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationUtils; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationUtils;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.FieldVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.SelectListGeneratorVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.SelectListGeneratorVTwo;
import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch; import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch;
import edu.cornell.mannlib.vitro.webapp.web.MiscWebUtils; import edu.cornell.mannlib.vitro.webapp.web.MiscWebUtils;
@ -372,8 +372,6 @@ public class MenuEditingFormGenerator implements EditConfigurationGenerator {
List<String> validators = new ArrayList<String>(); List<String> validators = new ArrayList<String>();
validators.add("nonempty"); validators.add("nonempty");
field.setValidators(validators); field.setValidators(validators);
field.setOptionsType("LITERALS");
field.setPredicateUri(DisplayVocabulary.DISPLAY_NS + "title");
fields.put("title", field); fields.put("title", field);
//Object Var Field //Object Var Field

18
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/generators/NewIndividualFormGenerator.java
View file

@ -37,8 +37,8 @@ import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.AntiXssValidation; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.AntiXssValidation;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.RdfLiteralHash; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.RdfLiteralHash;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditN3GeneratorVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditN3GeneratorVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.SelectListGeneratorVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.FieldVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.SelectListGeneratorVTwo;
import edu.cornell.mannlib.vitro.webapp.web.MiscWebUtils; import edu.cornell.mannlib.vitro.webapp.web.MiscWebUtils;
import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch; import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch;
@ -244,24 +244,12 @@ public class NewIndividualFormGenerator implements EditConfigurationGenerator {
VitroRequest vreq, Map<String, FieldVTwo> fields) { VitroRequest vreq, Map<String, FieldVTwo> fields) {
FieldVTwo field = new FieldVTwo(); FieldVTwo field = new FieldVTwo();
field.setName("label"); field.setName("label");
//queryForExisting is not being used anywhere in Field field.setRangeDatatypeUri( XSD.xstring.toString() );
String stringDatatypeUri = XSD.xstring.toString();
List<String> validators = new ArrayList<String>(); List<String> validators = new ArrayList<String>();
validators.add("nonempty"); validators.add("nonempty");
field.setValidators(validators); field.setValidators(validators);
//subjectUri and subjectClassUri are not being used in Field
field.setOptionsType("UNDEFINED");
//why isn't predicate uri set for data properties?
field.setPredicateUri(null);
field.setObjectClassUri(null);
field.setRangeDatatypeUri(stringDatatypeUri);
field.setLiteralOptions(new ArrayList<List<String>>());
fields.put(field.getName(), field); fields.put(field.getName(), field);
editConfiguration.setFields(fields); editConfiguration.setFields(fields);
} }

18
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/generators/RDFSLabelGenerator.java
View file

@ -34,8 +34,8 @@ import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.Field;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.AntiXssValidation; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators.AntiXssValidation;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.RdfLiteralHash; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.RdfLiteralHash;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditN3GeneratorVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditN3GeneratorVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.SelectListGeneratorVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.FieldVTwo; import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.SelectListGeneratorVTwo;
import edu.cornell.mannlib.vitro.webapp.web.MiscWebUtils; import edu.cornell.mannlib.vitro.webapp.web.MiscWebUtils;
import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch; import edu.cornell.mannlib.vitro.webapp.search.beans.ProhibitedFromSearch;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary; import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
@ -232,32 +232,18 @@ public class RDFSLabelGenerator implements EditConfigurationGenerator {
String rangeLang = getRangeLang(editConfiguration, vreq); String rangeLang = getRangeLang(editConfiguration, vreq);
List<String> validators = getFieldValidators(editConfiguration, vreq); List<String> validators = getFieldValidators(editConfiguration, vreq);
field.setValidators(validators); field.setValidators(validators);
//subjectUri and subjectClassUri are not being used in Field
field.setOptionsType("UNDEFINED");
//why isn't predicate uri set for data properties?
field.setPredicateUri(null);
field.setObjectClassUri(null);
field.setRangeDatatypeUri(rangeDatatypeUri); field.setRangeDatatypeUri(rangeDatatypeUri);
//have either range datatype uri or range lang, otherwise results in error //have either range datatype uri or range lang, otherwise results in error
if(rangeDatatypeUri == null) { if(rangeDatatypeUri == null) {
field.setRangeLang(rangeLang); field.setRangeLang(rangeLang);
} }
field.setLiteralOptions(getLiteralOptions(editConfiguration, vreq));
fields.put(field.getName(), field); fields.put(field.getName(), field);
return fields; return fields;
} }
private List<List<String>> getLiteralOptions(
EditConfigurationVTwo editConfiguration, VitroRequest vreq) {
DataPropertyStatement dps =EditConfigurationUtils.getDataPropertyStatement(vreq, vreq.getSession(), dataHash, predicateUri);
List<List<String>> literalOptions = new ArrayList<List<String>>();
return literalOptions;
}
private String getRangeLang(EditConfigurationVTwo editConfiguration, private String getRangeLang(EditConfigurationVTwo editConfiguration,
VitroRequest vreq) { VitroRequest vreq) {

49
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/generators/RdfTypeGenerator.java Normal file
View file

@ -0,0 +1,49 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.generators;
import java.util.Arrays;
import javax.servlet.http.HttpSession;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.vocabulary.OWL;
import com.hp.hpl.jena.vocabulary.RDF;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.ChildVClassesOptions;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
public class RdfTypeGenerator extends BaseEditConfigurationGenerator implements EditConfigurationGenerator {
private Log log = LogFactory.getLog(RdfTypeGenerator.class);
@Override
public EditConfigurationVTwo getEditConfiguration( VitroRequest vreq, HttpSession session) {
EditConfigurationVTwo editConfig = new EditConfigurationVTwo();
//get editkey and url of form
initBasics(editConfig, vreq);
initPropertyParameters(vreq, session, editConfig);
initObjectPropForm(editConfig, vreq);
editConfig.addUrisInScope("rdfTypeUri", Arrays.asList( RDF.type.getURI() ) );
editConfig.setN3Required( " ?subject ?rdfTypeUri ?object . ");
//set fields
editConfig.setUrisOnForm("object");
editConfig.addField( new FieldVTwo( )
.setName("object")
.setOptions(
new ChildVClassesOptions(OWL.Class.getURI()) )
);
editConfig.setTemplate("rdfTypeForm.ftl");
return editConfig;
}
}

274
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/preprocessors/ManagePagePreprocessor.java Normal file
View file

@ -0,0 +1,274 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.rdf.model.Literal;
import com.hp.hpl.jena.vocabulary.RDFS;
import com.hp.hpl.jena.vocabulary.XSD;
import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.BaseEditSubmissionPreprocessorVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationUtils;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.EditConfigurationVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.MultiValueEditSubmission;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.generators.ManagePageGenerator;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors.utils.ProcessDataGetterN3;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors.utils.ProcessDataGetterN3Utils;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;
public class ManagePagePreprocessor extends
BaseEditSubmissionPreprocessorVTwo {
protected static final Log log = LogFactory
.getLog(ManagePagePreprocessor.class.getName());
private static MultiValueEditSubmission submission = null;
private static EditConfigurationVTwo editConfiguration = null;
private static Map<String, List<String>> transformedLiteralsFromForm = null;
private static Map<String, List<String>> urisFromForm = null;
private static List<String> pageContentUnits = null;//String submission from form
private static List<JSONObject> pageContentUnitsJSON = null;//converted to JSON objects that can be read
// String datatype
// Will be editing the edit configuration as well as edit submission here
public ManagePagePreprocessor(EditConfigurationVTwo editConfig) {
super(editConfig);
editConfiguration = editConfig;
}
public void preprocess(MultiValueEditSubmission inputSubmission) {
submission = inputSubmission;
// Get the input elements for concept node and concept label as well
// as vocab uri (which is based on thge
// For query parameters, check whether CUI
copySubmissionValues();
processDataGetters();
}
//Since we will change the uris and literals from form, we should make copies
//of the original values and store them, this will also make iterations
//and updates to the submission independent from accessing the values
private void copySubmissionValues() {
Map<String, List<Literal>> literalsFromForm = submission.getLiteralsFromForm();
transformedLiteralsFromForm = copyMap(EditConfigurationUtils.transformLiteralMap(literalsFromForm));
urisFromForm = copyMap(submission.getUrisFromForm());
pageContentUnits = transformedLiteralsFromForm.get("pageContentUnit");
}
private Map<String, List<String>> copyMap(
Map<String, List<String>> originalMap) {
Map<String, List<String>> copyMap = new HashMap<String, List<String>>();
copyMap.putAll(originalMap);
return copyMap;
}
private void processDataGetters() {
convertToJson();
int counter = 0;
for(JSONObject jsonObject:pageContentUnitsJSON) {
String dataGetterClass = getDataGetterClass(jsonObject);
ProcessDataGetterN3 pn = ProcessDataGetterN3Utils.getDataGetterProcessorN3(dataGetterClass);
//Add n3 required
addN3Required(pn, counter);
//Add N3 Optional as well
addN3Optional(pn, counter);
// Add URIs on Form and Add Literals On Form
addLiteralsAndUrisOnForm(pn, counter);
// Add fields
addFields(pn, counter);
//Add new resources - data getters need to be new resources
addNewResources(pn, counter);
//Add input values to submission
addInputsToSubmission(pn, counter, jsonObject);
counter++;
}
}
private void addNewResources(ProcessDataGetterN3 pn, int counter) {
// TODO Auto-generated method stub
List<String> newResources = pn.getNewResources(counter);
for(String newResource:newResources) {
editConfiguration.addNewResource(newResource, ManagePageGenerator.defaultDisplayNs);
}
}
private void convertToJson() {
//Iterate through list of inputs
pageContentUnitsJSON = new ArrayList<JSONObject>();
for(String pageContentUnit: pageContentUnits) {
JSONObject jsonObject = (JSONObject) JSONSerializer.toJSON( pageContentUnit );
pageContentUnitsJSON.add(jsonObject);
}
}
//This is where the actual values will be submitted as if they were separate input fields
//Each field name will correspond to the names of the fileds/uris on form/literals on form
//generated here
private void addInputsToSubmission(ProcessDataGetterN3 pn, int counter, JSONObject jsonObject) {
List<String> literalLabels = pn.getLiteralVarNamesBase();
List<String> uriLabels = pn.getUriVarNamesBase();
for(String literalLabel:literalLabels) {
//TODO: Deal with multiple submission values
//This retrieves the value for this particular json object
String literalValue = jsonObject.getString(literalLabel);
//Var names will depend on which data getter object this is on the page, so depends on counter
String submissionLiteralName = pn.getVarName(literalLabel, counter);
//This adds literal, connecting the field with
submission.addLiteralToForm(editConfiguration, editConfiguration.getField(submissionLiteralName), submissionLiteralName, new String[]{literalValue});
}
for(String uriLabel:uriLabels) {
//TODO: Deal with multiple submission values
//This retrieves the value for this particular json object
String uriValue = jsonObject.getString(uriLabel);
//Var names will depend on which data getter object this is on the page, so depends on counter
String submissionUriName = pn.getVarName(uriLabel, counter);
//This adds literal, connecting the field with
submission.addLiteralToForm(editConfiguration, editConfiguration.getField(submissionUriName), submissionUriName, new String[]{uriValue});
}
//this needs to be different
//Get the literals directly from the processor - which you can get based on counter
//Problem then is we know what the connection is - some way to put that logic within the processor itself?
//It already knows the json object
//--> Get field for this base label, with counter value - that you get from configuration
/*
while(jsonObject.keys().hasNext())
{
//Other than class, all other variables considered a submission value corresponding to field
String key = (String) jsonObject.keys().next();
if(key != "dataGetterClass") {
//not expecting multiple values, so will need to either make this array or
//think about this some more
//TODO: Consider multiple values here
Map<String, String[]> submissionValues = new HashMap<String, String[]>();
submissionValues.put(key, new String[]{jsonObject.getString(key)} );
if(literalLabels.contains(key)) {
submission.addLiteralToForm(editConfiguration.getField(key), field, var, valuesArray)
}
}
}
List<String> uris = pn.retrieveUrissOnForm(counter);
for(String l:literals) {
//json object should have
submissionValues.put(l, new String[]{jsonObject.getString(l)} );
}*/
}
private void addFields(ProcessDataGetterN3 pn, int counter) {
List<FieldVTwo> fields = pn.retrieveFields(counter);
editConfiguration.addFields(fields);
}
//original literals on form: label, uris on form: conceptNode and conceptSource
//This will overwrite the original values in the edit configuration
private void addLiteralsAndUrisOnForm(ProcessDataGetterN3 pn, int counter) {
List<String> literalsOnForm = pn.retrieveLiteralsOnForm(counter);
editConfiguration.addLiteralsOnForm(literalsOnForm);
List<String> urisOnForm = pn.retrieveUrisOnForm(counter);
editConfiguration.addUrisOnForm(urisOnForm);
}
// N3 being reproduced
/*
* ?subject ?predicate ?conceptNode .
*/
//This will overwrite the original with the set of new n3 required
private void addN3Required(ProcessDataGetterN3 pn, int counter) {
//Use the process utils to figure out what class required to retrieve the N3 required
List<String> requiredList = pn.retrieveN3Required(counter);
//Add connection between data getter and page
requiredList.addAll(getPageToDataGetterN3(pn, counter));
if(requiredList != null) {
editConfiguration.addN3Required(requiredList);
}
}
private List<String> getPageToDataGetterN3(
ProcessDataGetterN3 pn, int counter) {
String dataGetterVar = pn.getDataGetterVar(counter);
//Put this method in the generator but can be put elsewhere
String pageToDataGetterN3 = ManagePageGenerator.getDataGetterN3(dataGetterVar);
return Arrays.asList(pageToDataGetterN3);
}
//Add n3 optional
private void addN3Optional(ProcessDataGetterN3 pn, int counter) {
List<String> optionalList = pn.retrieveN3Optional(counter);
if(optionalList != null) {
editConfiguration.addN3Optional(optionalList);
}
}
private String[] convertDelimitedStringToArray(String inputString) {
String[] inputArray = new String[1];
if (inputString.indexOf(",") != -1) {
inputArray = inputString.split(",");
} else {
inputArray[0] = inputString;
}
return inputArray;
}
private Object getFirstElement(List inputList) {
if(inputList == null || inputList.size() == 0)
return null;
return inputList.get(0);
}
//Each JSON Object will indicate the type of the data getter within it
private String getDataGetterClass(JSONObject jsonObject) {
String javaURI = jsonObject.getString("dataGetterClass");
return getQualifiedDataGetterName(javaURI);
}
//Get rid of java: in front of class name
private String getQualifiedDataGetterName(String dataGetterTypeURI) {
String javaURI = "java:";
if(dataGetterTypeURI.startsWith(javaURI)) {
int beginIndex = javaURI.length();
return dataGetterTypeURI.substring(beginIndex);
}
return dataGetterTypeURI;
}
}

26
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/preprocessors/utils/ProcessDataGetterN3.java Normal file
View file

@ -0,0 +1,26 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors.utils;
import java.util.ArrayList;
import java.util.List;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
//Returns the appropriate n3 based on data getter
public interface ProcessDataGetterN3 {
public List<String> retrieveN3Required(int counter);
public List<String> retrieveN3Optional(int counter);
public List<String >retrieveLiteralsOnForm(int counter);
public List<String> retrieveUrisOnForm(int counter);
public List<FieldVTwo> retrieveFields(int counter);
public List<String> getLiteralVarNamesBase();
public List<String> getUriVarNamesBase();
public String getVarName(String base, int counter);
public String getDataGetterVar(int counter);
public List<String> getNewResources(int counter);
}

53
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/preprocessors/utils/ProcessDataGetterN3Utils.java Normal file
View file

@ -0,0 +1,53 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors.utils;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletContext;
import net.sf.json.JSONObject;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.rdf.model.RDFNode;
import com.hp.hpl.jena.rdf.model.ResourceFactory;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors.utils.ProcessDataGetterN3;
/*
* This class determines what n3 should be returned for a particular data getter and can be overwritten or extended in VIVO.
*/
public class ProcessDataGetterN3Utils {
private static final Log log = LogFactory.getLog(ProcessDataGetterN3Utils.class);
public static HashMap<String, String> getDataGetterTypeToProcessorMap() {
HashMap<String, String> map = new HashMap<String, String>();
map.put("edu.cornell.mannlib.vitro.webapp.utils.dataGetter.SparqlQueryDataGetter", "edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors.utils.ProcessSparqlDataGetterN3");
return map;
}
public static ProcessDataGetterN3 getDataGetterProcessorN3(String dataGetterClass) {
HashMap<String, String> map = getDataGetterTypeToProcessorMap();
//
if(map.containsKey(dataGetterClass)) {
String processorClass = map.get(dataGetterClass);
try {
Class<?> clz = Class.forName(processorClass);
//Don't actually need to pass in json object since that includes the actual submission values
ProcessDataGetterN3 pn = (ProcessDataGetterN3) clz.getConstructor().newInstance();
return pn;
} catch(Exception ex) {
log.error("Exception occurred in trying to get processor class for n3 for " + dataGetterClass, ex);
return null;
}
}
return null;
}
}

127
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/preprocessors/utils/ProcessSparqlDataGetterN3.java Normal file
View file

@ -0,0 +1,127 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.preprocessors.utils;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import com.hp.hpl.jena.rdf.model.Literal;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.VTwo.fields.FieldVTwo;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;
//Returns the appropriate n3 based on data getter
public class ProcessSparqlDataGetterN3 implements ProcessDataGetterN3 {
private static String classType = "java:edu.cornell.mannlib.vitro.webapp.utils.dataGetter.SparqlQueryDataGetter";
public ProcessSparqlDataGetterN3(){
}
//Pass in variable that represents the counter
//TODO: ensure correct model returned
//We shouldn't use the ACTUAL values here but generate the n3 required
public List<String> retrieveN3Required(int counter) {
String dataGetterVar = getDataGetterVar(counter);
String n3 = dataGetterVar + " a <" + classType + ">; \n" +
"display:queryModel " + getN3VarName("queryModel", counter) + "; \n" +
"display:saveToVar " + getN3VarName("saveToVar", counter) + "; \n" +
"display:query " + getN3VarName("query", counter) + " .";
List<String> requiredList = new ArrayList<String>();
requiredList.add(getPrefixes() + n3);
return requiredList;
}
public List<String> retrieveN3Optional(int counter) {
return null;
}
//placeholder so need "?" in front of the variable
public String getDataGetterVar(int counter) {
return "?dataGetter" + counter;
}
private String getPrefixes() {
return "@prefix display: <http://vitro.mannlib.cornell.edu/ontologies/display/1.1#> . \n" +
"@prefix rdfs:<http://www.w3.org/2000/01/rdf-schema#> . \n";
}
//Need to add method sfor returning the fields, literals on form, and all that
/*
* addLiteralsAndUrisOnForm(pn, counter);
// Add fields
addFields(pn, counter);
//Add input values to submission
addInputsToSubmission(pn, counter);
*/
public List<String> retrieveLiteralsOnForm(int counter) {
List<String> literalsOnForm = new ArrayList<String>();
literalsOnForm.add(getVarName("saveToVar",counter));
literalsOnForm.add(getVarName("query", counter));
return literalsOnForm;
}
public List<String> retrieveUrisOnForm(int counter) {
List<String> urisOnForm = new ArrayList<String>();
//We have no uris as far as I know.. well query Model is a uri
urisOnForm.add(getVarName("queryModel", counter));
return urisOnForm;
}
public List<FieldVTwo> retrieveFields(int counter) {
List<FieldVTwo> fields = new ArrayList<FieldVTwo>();
//An alternative way of doing this
/*
List<String> allFieldsBase = new ArrayList<String>();
allFieldsBase.addAll(getLiteralVarNamesBase());
allFieldsBase.addAll(getUriVarNamesBase());
for(String varName: allFieldsBase) {
fields.add(new FieldVTwo().setName(getVarName(varName, counter)));
} */
//For existing data getters
//fields.add(new FieldVTwo().setName(getVarName("dataGetter", counter)));
fields.add(new FieldVTwo().setName(getVarName("queryModel", counter)));
fields.add(new FieldVTwo().setName(getVarName("saveToVar", counter)));
fields.add(new FieldVTwo().setName(getVarName("query", counter)));
return fields;
}
public List<String> getLiteralVarNamesBase() {
return Arrays.asList("saveToVar", "query");
}
//these are for the fields ON the form
public List<String> getUriVarNamesBase() {
return Arrays.asList("queryModel");
}
public String getVarName(String base, int counter) {
return base + counter;
}
//For use within n3 strings, need a "?"
public String getN3VarName(String base, int counter) {
return "?" + getVarName(base, counter);
}
//Return name of new resources
public List<String> getNewResources(int counter) {
//Each data getter requires a new resource
List<String> newResources = new ArrayList<String>();
newResources.add("dataGetter" + counter);
return newResources;
}
}

154
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/validators/DateTimeIntervalValidation.java
View file

@ -1,154 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.validators;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.datatypes.xsd.XSDDateTime;
import com.hp.hpl.jena.rdf.model.Literal;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary.Precision;
import edu.cornell.mannlib.vitro.webapp.edit.elements.DateTimeWithPrecision;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.EditConfiguration;
import edu.cornell.mannlib.vitro.webapp.edit.n3editing.processEdit.EditSubmission;
public class DateTimeIntervalValidation implements N3Validator {
private static Log log = LogFactory.getLog(DateTimeIntervalValidation.class);
private String startFieldName;
private String endFieldName;
private String startValueName;
private String endValueName;
private String startPrecisionName;
private String endPrecisionName;
public DateTimeIntervalValidation(String startFieldName, String endFieldName){
this.startFieldName = startFieldName;
this.endFieldName = endFieldName;
startValueName = startFieldName + "-value";
endValueName = endFieldName + "-value";
startPrecisionName = startFieldName + "-precision";
endPrecisionName = endFieldName + "-precision";
}
public Map<String, String> validate(EditConfiguration editConfig,
EditSubmission editSub) {
Map<String, Literal> existingLiterals = editConfig.getLiteralsInScope();
Literal existingStartYear = existingLiterals.get(startValueName);
Literal existingEndYear = existingLiterals.get(endValueName);
Map<String, Literal> literalsFromForm = editSub.getLiteralsFromForm();
Literal formStartYear = literalsFromForm.get(startValueName);
Literal formEndYear = literalsFromForm.get(endValueName);
VitroVocabulary.Precision startPrecision = getPrecision(startPrecisionName, editConfig, editSub);
VitroVocabulary.Precision endPrecision = getPrecision(endPrecisionName, editConfig, editSub);
Map<String, String> errors = new HashMap<String, String>();
// NIHVIVO-2541 Commented out to allow end date with no start date
// if( formStartYear == null && formEndYear != null ){
// errors.put(startFieldName, "If there is an end date, there should be a start date");
// return errors;
// }
if (formStartYear != null && formEndYear != null) {
errors.putAll(checkDateLiterals(formStartYear, formEndYear, startPrecision, endPrecision));
} else if (formStartYear != null && existingEndYear != null) {
errors.putAll(checkDateLiterals(formStartYear, existingEndYear, startPrecision, endPrecision));
} else if (existingStartYear != null && formEndYear != null) {
errors.putAll(checkDateLiterals(existingStartYear, formEndYear, startPrecision, endPrecision));
} else if (existingStartYear != null && existingEndYear != null) {
errors.putAll(checkDateLiterals(existingStartYear, existingEndYear, startPrecision, endPrecision));
}
if (errors.size() != 0)
return errors;
else
return null;
}
private Precision getPrecision(String precisionVarName,
EditConfiguration editConfig, EditSubmission editSub) {
if( editSub != null
&& editSub.getUrisFromForm() != null
&& editSub.getUrisFromForm().containsKey(precisionVarName)){
String precisionStr = editSub.getUrisFromForm().get(precisionVarName);
VitroVocabulary.Precision precision = DateTimeWithPrecision.toPrecision( precisionStr );
if( precision == null )
log.warn("cannot convert " + precisionStr + " to a precision");
else
return precision;
}else if( editConfig != null
&& editConfig.getUrisInScope() != null
&& editConfig.getUrisInScope().containsKey(precisionVarName)){
String precisionStr = editConfig.getUrisInScope().get(precisionVarName);
VitroVocabulary.Precision precision = DateTimeWithPrecision.toPrecision( precisionStr );
if( precision == null )
log.warn("cannot convert " + precisionStr + " to a precision");
else
return precision;
}
//this is what is returned if a precision was not found in the config or submission
return null;
}
private Map<String, String> checkDateLiterals(
Literal startLit, Literal endLit,
VitroVocabulary.Precision startPrecision, VitroVocabulary.Precision endPrecision) {
Map<String, String> errors = new HashMap<String, String>();
if( endPrecision == null ){
//there is no end date, nothing to check
return errors;
}
try{
XSDDateTime startDate = (XSDDateTime)startLit.getValue();
XSDDateTime endDate = (XSDDateTime)endLit.getValue();
if( startDate != null && endDate!= null ){
Calendar startCal = startDate.asCalendar();
Calendar endCal = endDate.asCalendar();
if( endCal != null ){
if( !startCal.before( endCal ) ){
if( startPrecision == VitroVocabulary.Precision.YEAR
&& endPrecision == VitroVocabulary.Precision.YEAR ){
errors.putAll( checkYears(startCal,endCal));
}else{
errors.put(startFieldName, "Start must be before end");
errors.put(endFieldName, "End must be after start");
}
}
}
}
}catch(ClassCastException cce){
errors.put(startFieldName, "could not format start or end date");
errors.put(endFieldName, "could not format start or end date");
log.debug("could not format dates " + cce);
}
return errors;
}
private Map<? extends String, ? extends String> checkYears(
Calendar startCal, Calendar endCal) {
Map<String, String> errors = new HashMap<String, String>();
if( ! (endCal.get(Calendar.YEAR) >= startCal.get(Calendar.YEAR) )){
errors.put(startFieldName, "Start must be before end");
errors.put(endFieldName, "End must be after start");
}
return errors;
}
}

4
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/controller/EditRequestDispatchController.java
View file

@ -153,7 +153,7 @@ public class EditRequestDispatchController extends FreemarkerHttpServlet {
//TODO: should more of what happens in this method //TODO: should more of what happens in this method
//happen in the generators? //happen in the generators?
private EditConfigurationVTwo setupEditConfiguration(String editConfGeneratorName, private EditConfigurationVTwo setupEditConfiguration(String editConfGeneratorName,
VitroRequest vreq) { VitroRequest vreq) throws Exception {
HttpSession session = vreq.getSession(); HttpSession session = vreq.getSession();
EditConfigurationVTwo editConfig = EditConfigurationVTwo editConfig =
makeEditConfigurationVTwo( editConfGeneratorName, vreq, session); makeEditConfigurationVTwo( editConfGeneratorName, vreq, session);
@ -362,7 +362,7 @@ public class EditRequestDispatchController extends FreemarkerHttpServlet {
private EditConfigurationVTwo makeEditConfigurationVTwo( private EditConfigurationVTwo makeEditConfigurationVTwo(
String editConfGeneratorName, VitroRequest vreq, HttpSession session) { String editConfGeneratorName, VitroRequest vreq, HttpSession session) throws Exception {
EditConfigurationGenerator EditConfigurationVTwoGenerator = null; EditConfigurationGenerator EditConfigurationVTwoGenerator = null;

6
webapp/src/edu/cornell/mannlib/vitro/webapp/email/FreemarkerEmailFactory.java
View file

@ -25,6 +25,8 @@ import org.apache.commons.logging.LogFactory;
import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties; import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest; import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.FreemarkerConfiguration;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.FreemarkerConfigurationLoader;
import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus; import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus;
/** /**
@ -57,7 +59,9 @@ public class FreemarkerEmailFactory {
} }
FreemarkerEmailFactory factory = getFactory(vreq); FreemarkerEmailFactory factory = getFactory(vreq);
return new FreemarkerEmailMessage(vreq, factory.getEmailSession(), FreemarkerConfiguration fConfig = FreemarkerConfigurationLoader
.getConfig(vreq);
return new FreemarkerEmailMessage(fConfig, factory.getEmailSession(),
factory.getReplyToAddress()); factory.getReplyToAddress());
} }

18
webapp/src/edu/cornell/mannlib/vitro/webapp/email/FreemarkerEmailMessage.java
View file

@ -23,7 +23,6 @@ import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart; import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage; import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart; import javax.mail.internet.MimeMultipart;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
@ -48,9 +47,6 @@ public class FreemarkerEmailMessage {
private static final Log log = LogFactory private static final Log log = LogFactory
.getLog(FreemarkerEmailMessage.class); .getLog(FreemarkerEmailMessage.class);
private static final String CONFIG_ATTRIBUTE = "freemarkerConfig";
private final HttpServletRequest req;
private final Session session; private final Session session;
private final FreemarkerConfiguration config; private final FreemarkerConfiguration config;
@ -67,21 +63,11 @@ public class FreemarkerEmailMessage {
/** /**
* Package access - should only be created by the factory. * Package access - should only be created by the factory.
*/ */
FreemarkerEmailMessage(HttpServletRequest req, Session session, FreemarkerEmailMessage(FreemarkerConfiguration fConfig, Session session,
InternetAddress replyToAddress) { InternetAddress replyToAddress) {
this.req = req;
this.session = session; this.session = session;
this.replyToAddress = replyToAddress; this.replyToAddress = replyToAddress;
this.config = fConfig;
Object o = req.getAttribute(CONFIG_ATTRIBUTE);
if (!(o instanceof FreemarkerConfiguration)) {
String oClass = (o == null) ? "null" : o.getClass().getName();
throw new IllegalStateException(
"Request does not contain a Configuration at '"
+ CONFIG_ATTRIBUTE + "': " + oClass);
}
this.config = (FreemarkerConfiguration) o;
} }
public void addRecipient(RecipientType type, String emailAddress) { public void addRecipient(RecipientType type, String emailAddress) {

6
webapp/src/edu/cornell/mannlib/vitro/webapp/rdfservice/RDFService.java
View file

@ -146,4 +146,10 @@ public interface RDFService {
* @return ChangeSet an empty ChangeSet object * @return ChangeSet an empty ChangeSet object
*/ */
public ChangeSet manufactureChangeSet(); public ChangeSet manufactureChangeSet();
/**
* Free any resources held by this RDFService object
*/
public void close();
} }

11
webapp/src/edu/cornell/mannlib/vitro/webapp/rdfservice/RDFServiceFactory.java Normal file
View file

@ -0,0 +1,11 @@
package edu.cornell.mannlib.vitro.webapp.rdfservice;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
public interface RDFServiceFactory {
public RDFService getRDFService();
public RDFService getRDFService(VitroRequest vreq);
}

390
webapp/src/edu/cornell/mannlib/vitro/webapp/rdfservice/impl/RDFServiceImpl.java
View file

@ -3,24 +3,11 @@
package edu.cornell.mannlib.vitro.webapp.rdfservice.impl; package edu.cornell.mannlib.vitro.webapp.rdfservice.impl;
import java.io.ByteArrayInputStream; import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Iterator; import java.util.Iterator;
import java.util.List;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.openrdf.model.Resource;
import org.openrdf.query.MalformedQueryException;
import org.openrdf.query.QueryLanguage;
import org.openrdf.query.Update;
import org.openrdf.query.UpdateExecutionException;
import org.openrdf.repository.Repository;
import org.openrdf.repository.RepositoryConnection;
import org.openrdf.repository.RepositoryException;
import org.openrdf.repository.RepositoryResult;
import org.openrdf.repository.http.HTTPRepository;
import com.hp.hpl.jena.graph.Node; import com.hp.hpl.jena.graph.Node;
import com.hp.hpl.jena.graph.Triple; import com.hp.hpl.jena.graph.Triple;
@ -29,11 +16,9 @@ import com.hp.hpl.jena.query.QueryExecution;
import com.hp.hpl.jena.query.QueryExecutionFactory; import com.hp.hpl.jena.query.QueryExecutionFactory;
import com.hp.hpl.jena.query.QueryFactory; import com.hp.hpl.jena.query.QueryFactory;
import com.hp.hpl.jena.query.ResultSet; import com.hp.hpl.jena.query.ResultSet;
import com.hp.hpl.jena.query.ResultSetFormatter;
import com.hp.hpl.jena.rdf.model.Model; import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory; import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Statement; import com.hp.hpl.jena.sparql.resultset.XMLInput;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.vocabulary.RDF; import com.hp.hpl.jena.vocabulary.RDF;
import edu.cornell.mannlib.vitro.webapp.rdfservice.ChangeListener; import edu.cornell.mannlib.vitro.webapp.rdfservice.ChangeListener;
@ -47,66 +32,11 @@ import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFServiceException;
* to allow listening, logging and auditing. * to allow listening, logging and auditing.
*/ */
public class RDFServiceImpl implements RDFService { public abstract class RDFServiceImpl implements RDFService {
private static final Log log = LogFactory.getLog(RDFServiceImpl.class); private static final Log log = LogFactory.getLog(RDFServiceImpl.class);
private String endpointURI; protected String defaultWriteGraphURI;
private String defaultWriteGraphURI; protected ArrayList<ChangeListener> registeredListeners = new ArrayList<ChangeListener>();
private Repository repository;
private ArrayList<ChangeListener> registeredListeners;
/**
* Returns an RDFService for a remote repository
* @param String - URI of the SPARQL endpoint for the knowledge base
* @param String - URI of the default write graph within the knowledge base.
* this is the graph that will be written to when a graph
* is not explicitly specified.
*
* The default read graph is the union of all graphs in the
* knowledge base
*/
public RDFServiceImpl(String endpointURI, String defaultWriteGraphURI) {
this.endpointURI = endpointURI;
this.defaultWriteGraphURI = defaultWriteGraphURI;
this.repository = new HTTPRepository(endpointURI);
this.registeredListeners = new ArrayList<ChangeListener>();
}
/**
* Perform a series of additions to and or removals from specified graphs
* in the RDF store. preConditionSparql will be executed against the
* union of all the graphs in the knowledge base before any updates are made.
* If the precondition query returns a non-empty result no updates
* will be made.
*
* @param ChangeSet - a set of changes to be performed on the RDF store.
*
* @return boolean - indicates whether the precondition was satisfied
*/
@Override
public boolean changeSetUpdate(ChangeSet changeSet) throws RDFServiceException {
if (!isPreconditionSatisfied(changeSet.getPreconditionQuery(), changeSet.getPreconditionQueryType())) {
return false;
}
Iterator<ModelChange> csIt = changeSet.getModelChanges().iterator();
while (csIt.hasNext()) {
ModelChange modelChange = csIt.next();
if (modelChange.getOperation() == ModelChange.Operation.ADD) {
performAdd(modelChange);
} else if (modelChange.getOperation() == ModelChange.Operation.REMOVE) {
performRemove(modelChange);
} else {
log.error("unrecognized operation type");
}
}
return true;
}
/** /**
* If the given individual already exists in the default graph, throws an * If the given individual already exists in the default graph, throws an
@ -154,174 +84,14 @@ public class RDFServiceImpl implements RDFService {
throw new RDFServiceException("individual already exists"); throw new RDFServiceException("individual already exists");
} else { } else {
Triple triple = new Triple(Node.createURI(individualURI), RDF.type.asNode(), Node.createURI(individualTypeURI)); Triple triple = new Triple(Node.createURI(individualURI), RDF.type.asNode(), Node.createURI(individualTypeURI));
addTriple(triple, graphURI); //addTriple(triple, graphURI);
ChangeSet cs = this.manufactureChangeSet();
cs.addAddition(new ByteArrayInputStream(
sparqlTriple(triple).getBytes()), ModelSerializationFormat.N3, graphURI);
changeSetUpdate(cs);
} }
} }
/**
* Performs a SPARQL construct query against the knowledge base. The query may have
* an embedded graph identifier.
*
* @param String query - the SPARQL query to be executed against the RDF store
* @param RDFService.ModelSerializationFormat resultFormat - type of serialization for RDF result of the SPARQL query
* @param OutputStream outputStream - the result of the query
*
*/
@Override
public InputStream sparqlConstructQuery(String queryStr,
RDFServiceImpl.ModelSerializationFormat resultFormat) throws RDFServiceException {
Model model = ModelFactory.createDefaultModel();
Query query = QueryFactory.create(queryStr);
QueryExecution qe = QueryExecutionFactory.sparqlService(endpointURI, query);
try {
qe.execConstruct(model);
} finally {
qe.close();
}
ByteArrayOutputStream serializedModel = new ByteArrayOutputStream();
model.write(serializedModel,getSerializationFormatString(resultFormat));
InputStream result = new ByteArrayInputStream(serializedModel.toByteArray());
return result;
}
/**
* Performs a SPARQL describe query against the knowledge base. The query may have
* an embedded graph identifier.
*
* @param String query - the SPARQL query to be executed against the RDF store
* @param RDFService.ModelSerializationFormat resultFormat - type of serialization for RDF result of the SPARQL query
*
* @return InputStream - the result of the query
*
*/
@Override
public InputStream sparqlDescribeQuery(String queryStr,
RDFServiceImpl.ModelSerializationFormat resultFormat) throws RDFServiceException {
Model model = ModelFactory.createDefaultModel();
Query query = QueryFactory.create(queryStr);
QueryExecution qe = QueryExecutionFactory.sparqlService(endpointURI, query);
try {
qe.execDescribe(model);
} finally {
qe.close();
}
ByteArrayOutputStream serializedModel = new ByteArrayOutputStream();
model.write(serializedModel,getSerializationFormatString(resultFormat));
InputStream result = new ByteArrayInputStream(serializedModel.toByteArray());
return result;
}
/**
* Performs a SPARQL select query against the knowledge base. The query may have
* an embedded graph identifier.
*
* @param String query - the SPARQL query to be executed against the RDF store
* @param RDFService.ResultFormat resultFormat - format for the result of the Select query
*
* @return InputStream - the result of the query
*
*/
@Override
public InputStream sparqlSelectQuery(String queryStr, RDFService.ResultFormat resultFormat) throws RDFServiceException {
Query query = QueryFactory.create(queryStr);
QueryExecution qe = QueryExecutionFactory.sparqlService(endpointURI, query);
try {
ResultSet resultSet = qe.execSelect();
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
switch (resultFormat) {
case CSV:
ResultSetFormatter.outputAsCSV(outputStream,resultSet);
break;
case TEXT:
ResultSetFormatter.out(outputStream,resultSet);
break;
case JSON:
ResultSetFormatter.outputAsJSON(outputStream, resultSet);
break;
case XML:
ResultSetFormatter.outputAsXML(outputStream, resultSet);
break;
default:
throw new RDFServiceException("unrecognized result format");
}
InputStream result = new ByteArrayInputStream(outputStream.toByteArray());
return result;
} finally {
qe.close();
}
}
/**
* Performs a SPARQL ASK query against the knowledge base. The query may have
* an embedded graph identifier.
*
* @param String query - the SPARQL query to be executed against the RDF store
*
* @return boolean - the result of the SPARQL query
*/
@Override
public boolean sparqlAskQuery(String queryStr) throws RDFServiceException {
Query query = QueryFactory.create(queryStr);
QueryExecution qe = QueryExecutionFactory.sparqlService(endpointURI, query);
try {
return qe.execAsk();
} finally {
qe.close();
}
}
/**
* Get a list of all the graph URIs in the RDF store.
*
* @return List<String> - list of all the graph URIs in the RDF store
*/
//TODO - need to verify that the sesame getContextIDs method is implemented
// in such a way that it works with all triple stores that support the
// graph update API
@Override
public List<String> getGraphURIs() throws RDFServiceException {
List<String> graphNodeList = new ArrayList<String>();
try {
RepositoryConnection conn = getConnection();
try {
RepositoryResult<Resource> conResult = conn.getContextIDs();
while (conResult.hasNext()) {
Resource res = conResult.next();
graphNodeList.add(res.stringValue());
}
} finally {
conn.close();
}
} catch (RepositoryException re) {
throw new RuntimeException(re);
}
return graphNodeList;
}
/**
* TODO - what is the definition of this method?
* @return
*/
@Override
public void getGraphMetadata() throws RDFServiceException {
}
/** /**
* Get the URI of the default write graph * Get the URI of the default write graph
* *
@ -365,93 +135,16 @@ public class RDFServiceImpl implements RDFService {
return new ChangeSetImpl(); return new ChangeSetImpl();
} }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ public synchronized void notifyListeners(Triple triple, ModelChange.Operation operation, String graphURI) {
// Non-override methods below
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
protected String getEndpointURI() {
return endpointURI;
}
protected RepositoryConnection getConnection() {
try {
return this.repository.getConnection();
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
protected void executeUpdate(String updateString) {
try {
RepositoryConnection conn = getConnection();
try {
Update u = conn.prepareUpdate(QueryLanguage.SPARQL, updateString);
u.execute();
} catch (MalformedQueryException e) {
throw new RuntimeException(e);
} catch (UpdateExecutionException e) {
log.error(e,e);
log.error("Update command: \n" + updateString);
throw new RuntimeException(e);
} finally {
conn.close();
}
} catch (RepositoryException re) {
throw new RuntimeException(re);
}
}
protected void addTriple(Triple t, String graphURI) {
StringBuffer updateString = new StringBuffer();
updateString.append("INSERT DATA { ");
updateString.append((graphURI != null) ? "GRAPH <" + graphURI + "> { " : "" );
updateString.append(sparqlNodeUpdate(t.getSubject(), ""));
updateString.append(" ");
updateString.append(sparqlNodeUpdate(t.getPredicate(), ""));
updateString.append(" ");
updateString.append(sparqlNodeUpdate(t.getObject(), ""));
updateString.append(" }");
updateString.append((graphURI != null) ? " } " : "");
executeUpdate(updateString.toString());
notifyListeners(t, ModelChange.Operation.ADD, graphURI);
}
protected void removeTriple(Triple t, String graphURI) {
StringBuffer updateString = new StringBuffer();
updateString.append("DELETE DATA { ");
updateString.append((graphURI != null) ? "GRAPH <" + graphURI + "> { " : "" );
updateString.append(sparqlNodeUpdate(t.getSubject(), ""));
updateString.append(" ");
updateString.append(sparqlNodeUpdate(t.getPredicate(), ""));
updateString.append(" ");
updateString.append(sparqlNodeUpdate(t.getObject(), ""));
updateString.append(" }");
updateString.append((graphURI != null) ? " } " : "");
executeUpdate(updateString.toString());
notifyListeners(t, ModelChange.Operation.REMOVE, graphURI);
}
protected synchronized void notifyListeners(Triple triple, ModelChange.Operation operation, String graphURI) {
StringBuffer serializedTriple = new StringBuffer();
serializedTriple.append(sparqlNodeUpdate(triple.getSubject(), ""));
serializedTriple.append(" ");
serializedTriple.append(sparqlNodeUpdate(triple.getPredicate(), ""));
serializedTriple.append(" ");
serializedTriple.append(sparqlNodeUpdate(triple.getObject(), ""));
serializedTriple.append(" .");
Iterator<ChangeListener> iter = registeredListeners.iterator(); Iterator<ChangeListener> iter = registeredListeners.iterator();
while (iter.hasNext()) { while (iter.hasNext()) {
ChangeListener listener = iter.next(); ChangeListener listener = iter.next();
if (operation == ModelChange.Operation.ADD) { if (operation == ModelChange.Operation.ADD) {
listener.addedStatement(serializedTriple.toString(), graphURI); listener.addedStatement(sparqlTriple(triple), graphURI);
} else { } else {
listener.removedStatement(serializedTriple.toString(), graphURI); listener.removedStatement(sparqlTriple(triple).toString(), graphURI);
} }
} }
} }
@ -460,7 +153,6 @@ public class RDFServiceImpl implements RDFService {
RDFService.SPARQLQueryType queryType) RDFService.SPARQLQueryType queryType)
throws RDFServiceException { throws RDFServiceException {
Model model = ModelFactory.createDefaultModel(); Model model = ModelFactory.createDefaultModel();
switch (queryType) { switch (queryType) {
case DESCRIBE: case DESCRIBE:
model.read(sparqlDescribeQuery(query,RDFService.ModelSerializationFormat.N3), null); model.read(sparqlDescribeQuery(query,RDFService.ModelSerializationFormat.N3), null);
@ -477,47 +169,6 @@ public class RDFServiceImpl implements RDFService {
} }
} }
protected boolean sparqlSelectQueryHasResults(String queryStr) throws RDFServiceException {
Query query = QueryFactory.create(queryStr);
QueryExecution qe = QueryExecutionFactory.sparqlService(endpointURI, query);
try {
ResultSet resultSet = qe.execSelect();
return resultSet.hasNext();
} finally {
qe.close();
}
}
protected void performAdd(ModelChange modelChange) throws RDFServiceException {
Model model = ModelFactory.createDefaultModel();
model.read(modelChange.getSerializedModel(),getSerializationFormatString(modelChange.getSerializationFormat()));
StmtIterator stmtIt = model.listStatements();
while (stmtIt.hasNext()) {
Statement stmt = stmtIt.next();
Triple triple = new Triple(stmt.getSubject().asNode(), stmt.getPredicate().asNode(), stmt.getObject().asNode());
addTriple(triple, modelChange.getGraphURI());
}
}
protected void performRemove(ModelChange modelChange) throws RDFServiceException {
Model model = ModelFactory.createDefaultModel();
model.read(modelChange.getSerializedModel(),getSerializationFormatString(modelChange.getSerializationFormat()));
StmtIterator stmtIt = model.listStatements();
while (stmtIt.hasNext()) {
Statement stmt = stmtIt.next();
Triple triple = new Triple(stmt.getSubject().asNode(), stmt.getPredicate().asNode(), stmt.getObject().asNode());
removeTriple(triple, modelChange.getGraphURI());
}
}
protected static String getSerializationFormatString(RDFService.ModelSerializationFormat format) { protected static String getSerializationFormatString(RDFService.ModelSerializationFormat format) {
switch (format) { switch (format) {
case RDFXML: case RDFXML:
@ -530,6 +181,23 @@ public class RDFServiceImpl implements RDFService {
} }
} }
protected boolean sparqlSelectQueryHasResults(String queryStr) throws RDFServiceException {
ResultSet rs = XMLInput.fromXML(sparqlSelectQuery(queryStr, ResultFormat.XML));
return rs.hasNext();
}
protected static String sparqlTriple(Triple triple) {
StringBuffer serializedTriple = new StringBuffer();
serializedTriple.append(sparqlNodeUpdate(triple.getSubject(), ""));
serializedTriple.append(" ");
serializedTriple.append(sparqlNodeUpdate(triple.getPredicate(), ""));
serializedTriple.append(" ");
serializedTriple.append(sparqlNodeUpdate(triple.getObject(), ""));
serializedTriple.append(" .");
return serializedTriple.toString();
}
protected static String sparqlNodeUpdate(Node node, String varName) { protected static String sparqlNodeUpdate(Node node, String varName) {
if (node.isBlank()) { if (node.isBlank()) {
return "_:" + node.getBlankNodeLabel().replaceAll("\\W", ""); return "_:" + node.getBlankNodeLabel().replaceAll("\\W", "");

22
webapp/src/edu/cornell/mannlib/vitro/webapp/rdfservice/impl/RDFServiceUtils.java Normal file
View file

@ -0,0 +1,22 @@
package edu.cornell.mannlib.vitro.webapp.rdfservice.impl;
import javax.servlet.ServletContext;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFServiceFactory;
public class RDFServiceUtils {
private static final String RDFSERVICEFACTORY_ATTR =
RDFServiceUtils.class.getName() + ".RDFServiceFactory";
public RDFServiceFactory getRDFServiceFactory(ServletContext context) {
Object o = context.getAttribute(RDFSERVICEFACTORY_ATTR);
return (o instanceof RDFServiceFactory) ? (RDFServiceFactory) o : null;
}
public void setRDFServiceFactory(ServletContext context,
RDFServiceFactory factory) {
context.setAttribute(RDFSERVICEFACTORY_ATTR, factory);
}
}

23
webapp/src/edu/cornell/mannlib/vitro/webapp/rdfservice/impl/sdb/RDFServiceFactorySDB.java Normal file
View file

@ -0,0 +1,23 @@
package edu.cornell.mannlib.vitro.webapp.rdfservice.impl.sdb;
import org.apache.commons.dbcp.BasicDataSource;
import com.hp.hpl.jena.sdb.StoreDesc;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFService;
public class RDFServiceFactorySDB {
private BasicDataSource bds;
private StoreDesc storeDesc;
public RDFServiceFactorySDB(BasicDataSource dataSource, StoreDesc storeDesc) {
this.bds = dataSource;
this.storeDesc = storeDesc;
}
public RDFService getRDFService() {
return new RDFServiceSDB(bds, storeDesc);
}
}

267
webapp/src/edu/cornell/mannlib/vitro/webapp/rdfservice/impl/sdb/RDFServiceSDB.java Normal file
View file

@ -0,0 +1,267 @@
package edu.cornell.mannlib.vitro.webapp.rdfservice.impl.sdb;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.query.Dataset;
import com.hp.hpl.jena.query.Query;
import com.hp.hpl.jena.query.QueryExecution;
import com.hp.hpl.jena.query.QueryExecutionFactory;
import com.hp.hpl.jena.query.QueryFactory;
import com.hp.hpl.jena.query.ResultSet;
import com.hp.hpl.jena.query.ResultSetFormatter;
import com.hp.hpl.jena.rdf.listeners.StatementListener;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.sdb.SDBFactory;
import com.hp.hpl.jena.sdb.StoreDesc;
import com.hp.hpl.jena.sdb.sql.SDBConnection;
import edu.cornell.mannlib.vitro.webapp.dao.jena.DatasetWrapper;
import edu.cornell.mannlib.vitro.webapp.rdfservice.ChangeSet;
import edu.cornell.mannlib.vitro.webapp.rdfservice.ModelChange;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFService;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFServiceException;
import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.RDFServiceImpl;
public class RDFServiceSDB extends RDFServiceImpl implements RDFService {
private final static Log log = LogFactory.getLog(RDFServiceSDB.class);
private BasicDataSource bds;
private StoreDesc storeDesc;
public RDFServiceSDB(BasicDataSource dataSource, StoreDesc storeDesc) {
this.bds = dataSource;
this.storeDesc = storeDesc;
}
protected DatasetWrapper getDatasetWrapper() {
try {
SDBConnection conn = new SDBConnection(bds.getConnection());
Dataset dataset = SDBFactory.connectDataset(conn, storeDesc);
return new DatasetWrapper(dataset, conn);
} catch (SQLException sqle) {
log.error(sqle, sqle);
throw new RuntimeException(sqle);
}
}
@Override
public boolean changeSetUpdate(ChangeSet changeSet)
throws RDFServiceException {
if (changeSet.getPreconditionQuery() != null
&& !isPreconditionSatisfied(
changeSet.getPreconditionQuery(),
changeSet.getPreconditionQueryType())) {
return false;
}
Iterator<ModelChange> csIt = changeSet.getModelChanges().iterator();
SDBConnection conn = null;
try {
conn = new SDBConnection(bds.getConnection());
} catch (SQLException sqle) {
log.error(sqle, sqle);
throw new RuntimeException(sqle);
}
Dataset dataset = SDBFactory.connectDataset(conn, storeDesc);
boolean transaction = conn.getTransactionHandler().transactionsSupported();
try {
if (transaction) {
conn.getTransactionHandler().begin();
}
while (csIt.hasNext()) {
ModelChange modelChange = csIt.next();
Model model = dataset.getNamedModel(modelChange.getGraphURI());
model.register(new ModelListener(modelChange.getGraphURI(), this));
if (modelChange.getOperation() == ModelChange.Operation.ADD) {
model.add(parseModel(modelChange));
} else if (modelChange.getOperation() == ModelChange.Operation.REMOVE) {
model.remove(parseModel(modelChange));
} else {
log.error("unrecognized operation type");
}
}
} catch (Throwable t) {
if (transaction) {
conn.getTransactionHandler().abort();
}
throw new RuntimeException(t);
} finally {
if (transaction) {
conn.getTransactionHandler().commit();
}
conn.close();
}
return true;
}
private Model parseModel(ModelChange modelChange) {
Model model = ModelFactory.createDefaultModel();
model.read(modelChange.getSerializedModel(),
getSerializationFormatString(modelChange.getSerializationFormat()));
return model;
}
@Override
public void newIndividual(String individualURI, String individualTypeURI,
String graphURI) throws RDFServiceException {
// TODO Auto-generated method stub
}
private InputStream getRDFResultStream(String query, boolean construct,
ModelSerializationFormat resultFormat) throws RDFServiceException {
DatasetWrapper dw = getDatasetWrapper();
try {
Dataset d = dw.getDataset();
Query q = QueryFactory.create(query);
QueryExecution qe = QueryExecutionFactory.create(q, d);
ByteArrayOutputStream serializedModel = new ByteArrayOutputStream();
try {
// TODO pipe this
Model m = construct ? qe.execConstruct() : qe.execDescribe();
m.write(serializedModel, getSerializationFormatString(resultFormat));
InputStream result = new ByteArrayInputStream(serializedModel.toByteArray());
return result;
} finally {
qe.close();
}
} finally {
dw.close();
}
}
private static final boolean CONSTRUCT = true;
private static final boolean DESCRIBE = false;
@Override
public InputStream sparqlConstructQuery(String query,
ModelSerializationFormat resultFormat) throws RDFServiceException {
return getRDFResultStream(query, CONSTRUCT, resultFormat);
}
@Override
public InputStream sparqlDescribeQuery(String query,
ModelSerializationFormat resultFormat) throws RDFServiceException {
return getRDFResultStream(query, DESCRIBE, resultFormat);
}
@Override
public InputStream sparqlSelectQuery(String query, ResultFormat resultFormat)
throws RDFServiceException {
DatasetWrapper dw = getDatasetWrapper();
try {
Dataset d = dw.getDataset();
Query q = QueryFactory.create(query);
QueryExecution qe = QueryExecutionFactory.create(q, d);
try {
ResultSet resultSet = qe.execSelect();
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
switch (resultFormat) {
case CSV:
ResultSetFormatter.outputAsCSV(outputStream,resultSet);
break;
case TEXT:
ResultSetFormatter.out(outputStream,resultSet);
break;
case JSON:
ResultSetFormatter.outputAsJSON(outputStream, resultSet);
break;
case XML:
ResultSetFormatter.outputAsXML(outputStream, resultSet);
break;
default:
throw new RDFServiceException("unrecognized result format");
}
InputStream result = new ByteArrayInputStream(outputStream.toByteArray());
return result;
} finally {
qe.close();
}
} finally {
dw.close();
}
}
@Override
public boolean sparqlAskQuery(String query) throws RDFServiceException {
DatasetWrapper dw = getDatasetWrapper();
try {
Dataset d = dw.getDataset();
Query q = QueryFactory.create(query);
QueryExecution qe = QueryExecutionFactory.create(q, d);
try {
return qe.execAsk();
} finally {
qe.close();
}
} finally {
dw.close();
}
}
@Override
public List<String> getGraphURIs() throws RDFServiceException {
DatasetWrapper dw = getDatasetWrapper();
try {
Dataset d = dw.getDataset();
List<String> graphURIs = new ArrayList<String>();
Iterator<String> nameIt = d.listNames();
while (nameIt.hasNext()) {
graphURIs.add(nameIt.next());
}
return graphURIs;
} finally {
dw.close();
}
}
@Override
public void getGraphMetadata() throws RDFServiceException {
// TODO Auto-generated method stub
}
@Override
public void close() {
// nothing
}
private class ModelListener extends StatementListener {
private String graphURI;
private RDFServiceImpl s;
public ModelListener(String graphURI, RDFServiceImpl s) {
this.graphURI = graphURI;
this.s = s;
}
public void addedStatement(Statement stmt) {
s.notifyListeners(stmt.asTriple(), ModelChange.Operation.ADD, graphURI);
}
public void removedStatement(Statement stmt) {
s.notifyListeners(stmt.asTriple(), ModelChange.Operation.REMOVE, graphURI);
}
}
}

460
webapp/src/edu/cornell/mannlib/vitro/webapp/rdfservice/impl/sparql/RDFServiceSparql.java Normal file
View file

@ -0,0 +1,460 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.rdfservice.impl.sparql;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.openrdf.model.Resource;
import org.openrdf.query.MalformedQueryException;
import org.openrdf.query.QueryLanguage;
import org.openrdf.query.Update;
import org.openrdf.query.UpdateExecutionException;
import org.openrdf.repository.Repository;
import org.openrdf.repository.RepositoryConnection;
import org.openrdf.repository.RepositoryException;
import org.openrdf.repository.RepositoryResult;
import org.openrdf.repository.http.HTTPRepository;
import com.hp.hpl.jena.graph.Node;
import com.hp.hpl.jena.graph.Triple;
import com.hp.hpl.jena.query.Query;
import com.hp.hpl.jena.query.QueryExecution;
import com.hp.hpl.jena.query.QueryExecutionFactory;
import com.hp.hpl.jena.query.QueryFactory;
import com.hp.hpl.jena.query.ResultSet;
import com.hp.hpl.jena.query.ResultSetFormatter;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.vocabulary.RDF;
import edu.cornell.mannlib.vitro.webapp.rdfservice.ChangeListener;
import edu.cornell.mannlib.vitro.webapp.rdfservice.ChangeSet;
import edu.cornell.mannlib.vitro.webapp.rdfservice.ModelChange;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFService;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFServiceException;
import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.ChangeSetImpl;
import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.RDFServiceImpl;
/*
* API to write, read, and update Vitro's RDF store, with support
* to allow listening, logging and auditing.
*/
public class RDFServiceSparql extends RDFServiceImpl implements RDFService {
private static final Log log = LogFactory.getLog(RDFServiceImpl.class);
private String endpointURI;
private Repository repository;
/**
* Returns an RDFService for a remote repository
* @param String - URI of the SPARQL endpoint for the knowledge base
* @param String - URI of the default write graph within the knowledge base.
* this is the graph that will be written to when a graph
* is not explicitly specified.
*
* The default read graph is the union of all graphs in the
* knowledge base
*/
public RDFServiceSparql(String endpointURI, String defaultWriteGraphURI) {
this.endpointURI = endpointURI;
this.repository = new HTTPRepository(endpointURI);
}
public void close() {
try {
this.repository.shutDown();
} catch (RepositoryException re) {
log.error(re, re);
}
}
/**
* Perform a series of additions to and or removals from specified graphs
* in the RDF store. preConditionSparql will be executed against the
* union of all the graphs in the knowledge base before any updates are made.
* If the precondition query returns a non-empty result no updates
* will be made.
*
* @param ChangeSet - a set of changes to be performed on the RDF store.
*
* @return boolean - indicates whether the precondition was satisfied
*/
@Override
public boolean changeSetUpdate(ChangeSet changeSet) throws RDFServiceException {
if (changeSet.getPreconditionQuery() != null
&& !isPreconditionSatisfied(
changeSet.getPreconditionQuery(),
changeSet.getPreconditionQueryType())) {
return false;
}
Iterator<ModelChange> csIt = changeSet.getModelChanges().iterator();
while (csIt.hasNext()) {
ModelChange modelChange = csIt.next();
if (modelChange.getOperation() == ModelChange.Operation.ADD) {
performAdd(modelChange);
} else if (modelChange.getOperation() == ModelChange.Operation.REMOVE) {
performRemove(modelChange);
} else {
log.error("unrecognized operation type");
}
}
return true;
}
/**
* Performs a SPARQL construct query against the knowledge base. The query may have
* an embedded graph identifier.
*
* @param String query - the SPARQL query to be executed against the RDF store
* @param RDFService.ModelSerializationFormat resultFormat - type of serialization for RDF result of the SPARQL query
* @param OutputStream outputStream - the result of the query
*
*/
@Override
public InputStream sparqlConstructQuery(String queryStr,
RDFServiceImpl.ModelSerializationFormat resultFormat) throws RDFServiceException {
Model model = ModelFactory.createDefaultModel();
Query query = QueryFactory.create(queryStr);
QueryExecution qe = QueryExecutionFactory.sparqlService(endpointURI, query);
try {
qe.execConstruct(model);
} finally {
qe.close();
}
ByteArrayOutputStream serializedModel = new ByteArrayOutputStream();
model.write(serializedModel,getSerializationFormatString(resultFormat));
InputStream result = new ByteArrayInputStream(serializedModel.toByteArray());
return result;
}
/**
* Performs a SPARQL describe query against the knowledge base. The query may have
* an embedded graph identifier.
*
* @param String query - the SPARQL query to be executed against the RDF store
* @param RDFService.ModelSerializationFormat resultFormat - type of serialization for RDF result of the SPARQL query
*
* @return InputStream - the result of the query
*
*/
@Override
public InputStream sparqlDescribeQuery(String queryStr,
RDFServiceImpl.ModelSerializationFormat resultFormat) throws RDFServiceException {
Model model = ModelFactory.createDefaultModel();
Query query = QueryFactory.create(queryStr);
QueryExecution qe = QueryExecutionFactory.sparqlService(endpointURI, query);
try {
qe.execDescribe(model);
} finally {
qe.close();
}
ByteArrayOutputStream serializedModel = new ByteArrayOutputStream();
model.write(serializedModel,getSerializationFormatString(resultFormat));
InputStream result = new ByteArrayInputStream(serializedModel.toByteArray());
return result;
}
/**
* Performs a SPARQL select query against the knowledge base. The query may have
* an embedded graph identifier.
*
* @param String query - the SPARQL query to be executed against the RDF store
* @param RDFService.ResultFormat resultFormat - format for the result of the Select query
*
* @return InputStream - the result of the query
*
*/
@Override
public InputStream sparqlSelectQuery(String queryStr, RDFService.ResultFormat resultFormat) throws RDFServiceException {
Query query = QueryFactory.create(queryStr);
QueryExecution qe = QueryExecutionFactory.sparqlService(endpointURI, query);
try {
ResultSet resultSet = qe.execSelect();
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
switch (resultFormat) {
case CSV:
ResultSetFormatter.outputAsCSV(outputStream,resultSet);
break;
case TEXT:
ResultSetFormatter.out(outputStream,resultSet);
break;
case JSON:
ResultSetFormatter.outputAsJSON(outputStream, resultSet);
break;
case XML:
ResultSetFormatter.outputAsXML(outputStream, resultSet);
break;
default:
throw new RDFServiceException("unrecognized result format");
}
InputStream result = new ByteArrayInputStream(outputStream.toByteArray());
return result;
} finally {
qe.close();
}
}
/**
* Performs a SPARQL ASK query against the knowledge base. The query may have
* an embedded graph identifier.
*
* @param String query - the SPARQL query to be executed against the RDF store
*
* @return boolean - the result of the SPARQL query
*/
@Override
public boolean sparqlAskQuery(String queryStr) throws RDFServiceException {
Query query = QueryFactory.create(queryStr);
QueryExecution qe = QueryExecutionFactory.sparqlService(endpointURI, query);
try {
return qe.execAsk();
} finally {
qe.close();
}
}
/**
* Get a list of all the graph URIs in the RDF store.
*
* @return List<String> - list of all the graph URIs in the RDF store
*/
//TODO - need to verify that the sesame getContextIDs method is implemented
// in such a way that it works with all triple stores that support the
// graph update API
@Override
public List<String> getGraphURIs() throws RDFServiceException {
List<String> graphNodeList = new ArrayList<String>();
try {
RepositoryConnection conn = getConnection();
try {
RepositoryResult<Resource> conResult = conn.getContextIDs();
while (conResult.hasNext()) {
Resource res = conResult.next();
graphNodeList.add(res.stringValue());
}
} finally {
conn.close();
}
} catch (RepositoryException re) {
throw new RuntimeException(re);
}
return graphNodeList;
}
/**
* TODO - what is the definition of this method?
* @return
*/
@Override
public void getGraphMetadata() throws RDFServiceException {
}
/**
* Get the URI of the default write graph
*
* @return String URI of default write graph
*/
@Override
public String getDefaultWriteGraphURI() throws RDFServiceException {
return defaultWriteGraphURI;
}
/**
* Register a listener to listen to changes in any graph in
* the RDF store.
*
*/
@Override
public synchronized void registerListener(ChangeListener changeListener) throws RDFServiceException {
if (!registeredListeners.contains(changeListener)) {
registeredListeners.add(changeListener);
}
}
/**
* Unregister a listener from listening to changes in any graph
* in the RDF store.
*
*/
@Override
public synchronized void unregisterListener(ChangeListener changeListener) throws RDFServiceException {
registeredListeners.remove(changeListener);
}
/**
* Create a ChangeSet object
*
* @return a ChangeSet object
*/
@Override
public ChangeSet manufactureChangeSet() {
return new ChangeSetImpl();
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Non-override methods below
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
protected String getEndpointURI() {
return endpointURI;
}
protected RepositoryConnection getConnection() {
try {
return this.repository.getConnection();
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
protected void executeUpdate(String updateString) {
try {
RepositoryConnection conn = getConnection();
try {
Update u = conn.prepareUpdate(QueryLanguage.SPARQL, updateString);
u.execute();
} catch (MalformedQueryException e) {
throw new RuntimeException(e);
} catch (UpdateExecutionException e) {
log.error(e,e);
log.error("Update command: \n" + updateString);
throw new RuntimeException(e);
} finally {
conn.close();
}
} catch (RepositoryException re) {
throw new RuntimeException(re);
}
}
protected void addTriple(Triple t, String graphURI) {
StringBuffer updateString = new StringBuffer();
updateString.append("INSERT DATA { ");
updateString.append((graphURI != null) ? "GRAPH <" + graphURI + "> { " : "" );
updateString.append(sparqlNodeUpdate(t.getSubject(), ""));
updateString.append(" ");
updateString.append(sparqlNodeUpdate(t.getPredicate(), ""));
updateString.append(" ");
updateString.append(sparqlNodeUpdate(t.getObject(), ""));
updateString.append(" }");
updateString.append((graphURI != null) ? " } " : "");
executeUpdate(updateString.toString());
notifyListeners(t, ModelChange.Operation.ADD, graphURI);
}
protected void removeTriple(Triple t, String graphURI) {
StringBuffer updateString = new StringBuffer();
updateString.append("DELETE DATA { ");
updateString.append((graphURI != null) ? "GRAPH <" + graphURI + "> { " : "" );
updateString.append(sparqlNodeUpdate(t.getSubject(), ""));
updateString.append(" ");
updateString.append(sparqlNodeUpdate(t.getPredicate(), ""));
updateString.append(" ");
updateString.append(sparqlNodeUpdate(t.getObject(), ""));
updateString.append(" }");
updateString.append((graphURI != null) ? " } " : "");
executeUpdate(updateString.toString());
notifyListeners(t, ModelChange.Operation.REMOVE, graphURI);
}
@Override
protected boolean isPreconditionSatisfied(String query,
RDFService.SPARQLQueryType queryType)
throws RDFServiceException {
Model model = ModelFactory.createDefaultModel();
switch (queryType) {
case DESCRIBE:
model.read(sparqlDescribeQuery(query,RDFService.ModelSerializationFormat.N3), null);
return !model.isEmpty();
case CONSTRUCT:
model.read(sparqlConstructQuery(query,RDFService.ModelSerializationFormat.N3), null);
return !model.isEmpty();
case SELECT:
return sparqlSelectQueryHasResults(query);
case ASK:
return sparqlAskQuery(query);
default:
throw new RDFServiceException("unrecognized SPARQL query type");
}
}
@Override
protected boolean sparqlSelectQueryHasResults(String queryStr) throws RDFServiceException {
Query query = QueryFactory.create(queryStr);
QueryExecution qe = QueryExecutionFactory.sparqlService(endpointURI, query);
try {
ResultSet resultSet = qe.execSelect();
return resultSet.hasNext();
} finally {
qe.close();
}
}
protected void performAdd(ModelChange modelChange) throws RDFServiceException {
Model model = ModelFactory.createDefaultModel();
model.read(modelChange.getSerializedModel(),getSerializationFormatString(modelChange.getSerializationFormat()));
StmtIterator stmtIt = model.listStatements();
while (stmtIt.hasNext()) {
Statement stmt = stmtIt.next();
Triple triple = new Triple(stmt.getSubject().asNode(), stmt.getPredicate().asNode(), stmt.getObject().asNode());
addTriple(triple, modelChange.getGraphURI());
}
}
protected void performRemove(ModelChange modelChange) throws RDFServiceException {
Model model = ModelFactory.createDefaultModel();
model.read(modelChange.getSerializedModel(),getSerializationFormatString(modelChange.getSerializationFormat()));
StmtIterator stmtIt = model.listStatements();
while (stmtIt.hasNext()) {
Statement stmt = stmtIt.next();
Triple triple = new Triple(stmt.getSubject().asNode(), stmt.getPredicate().asNode(), stmt.getObject().asNode());
removeTriple(triple, modelChange.getGraphURI());
}
}
}

2
webapp/src/edu/cornell/mannlib/vitro/webapp/search/VitroSearchTermNames.java
View file

@ -25,8 +25,6 @@ public class VitroSearchTermNames {
public static String ALLTEXTUNSTEMMED = "ALLTEXTUNSTEMMED"; public static String ALLTEXTUNSTEMMED = "ALLTEXTUNSTEMMED";
/** Does the individual have a thumbnail image? 1=yes 0=no */ /** Does the individual have a thumbnail image? 1=yes 0=no */
public static final String THUMBNAIL = "THUMBNAIL"; public static final String THUMBNAIL = "THUMBNAIL";
/** Should individual be included in full text search results? 1=yes 0=no */
public static final String PROHIBITED_FROM_TEXT_RESULTS = "PROHIBITED_FROM_TEXT_RESULTS";
/** class names in human readable form of an individual*/ /** class names in human readable form of an individual*/
public static final String CLASSLOCALNAMELOWERCASE = "classLocalNameLowerCase"; public static final String CLASSLOCALNAMELOWERCASE = "classLocalNameLowerCase";
/** class names in human readable form of an individual*/ /** class names in human readable form of an individual*/

8
webapp/src/edu/cornell/mannlib/vitro/webapp/search/beans/IndividualProhibitedFromSearch.java
View file

@ -1,8 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.search.beans;
public interface IndividualProhibitedFromSearch {
public boolean isIndividualProhibited(String uri);
}

84
webapp/src/edu/cornell/mannlib/vitro/webapp/search/beans/IndividualProhibitedFromSearchImpl.java
View file

@ -1,84 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.search.beans;
import javax.servlet.ServletContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.query.Query;
import com.hp.hpl.jena.query.QueryExecution;
import com.hp.hpl.jena.query.QueryExecutionFactory;
import com.hp.hpl.jena.query.QueryFactory;
import com.hp.hpl.jena.shared.Lock;
import com.hp.hpl.jena.vocabulary.OWL;
import com.hp.hpl.jena.vocabulary.RDF;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
public class IndividualProhibitedFromSearchImpl implements IndividualProhibitedFromSearch {
protected OntModel fullModel;
protected static Log log = LogFactory.getLog(IndividualProhibitedFromSearchImpl.class);
public IndividualProhibitedFromSearchImpl( ServletContext context ){
this.fullModel = ModelContext.getUnionOntModelSelector(context).getFullModel();
}
public IndividualProhibitedFromSearchImpl( OntModel fullModel ){
this.fullModel = fullModel;
}
public boolean isIndividualProhibited(String uri){
if( uri == null || uri.isEmpty() )
return true;
boolean prohibited = false;
QueryExecution qexec = null;
try {
fullModel.getLock().enterCriticalSection(Lock.READ);
Query query = makeAskQueryForUri( uri );
qexec = QueryExecutionFactory.create( query, fullModel);
prohibited = qexec.execAsk();
} finally {
if( qexec != null ) qexec.close();
fullModel.getLock().leaveCriticalSection();
}
if( prohibited )
log.debug("prohibited " + uri);
return prohibited;
}
private Query makeAskQueryForUri( String uri ){
String queryString =
"PREFIX fn: <http://www.w3.org/2005/xpath-functions#> \n" +
"ASK { \n" +
" <"+uri+"> <" + RDF.type.getURI() + "> ?type . \n" +
" FILTER ( \n" +
" ( fn:starts-with( str(?type), \"" + VitroVocabulary.vitroURI + "\" ) \n" +
" && \n"+
" ! fn:starts-with( str(?type), \"" + VitroVocabulary.vitroURI + "Flag\" ) ) || \n" +
" fn:starts-with( str(?type), \"" + VitroVocabulary.PUBLIC + "\" ) || \n" +
" str(?type) = \"" + OWL.ObjectProperty.getURI() + "\" || \n" +
" str(?type) = \"" + OWL.DatatypeProperty.getURI() + "\" || \n" +
" str(?type) = \"" + OWL.AnnotationProperty.getURI() + "\" \n" +
" )\n" +
"}" ;
return QueryFactory.create( queryString );
}
}

4
webapp/src/edu/cornell/mannlib/vitro/webapp/search/controller/PagedSearchController.java
View file

@ -51,7 +51,6 @@ import edu.cornell.mannlib.vitro.webapp.search.beans.VitroQueryFactory;
import edu.cornell.mannlib.vitro.webapp.search.solr.SolrSetup; import edu.cornell.mannlib.vitro.webapp.search.solr.SolrSetup;
import edu.cornell.mannlib.vitro.webapp.web.templatemodels.LinkTemplateModel; import edu.cornell.mannlib.vitro.webapp.web.templatemodels.LinkTemplateModel;
import edu.cornell.mannlib.vitro.webapp.web.templatemodels.searchresult.IndividualSearchResult; import edu.cornell.mannlib.vitro.webapp.web.templatemodels.searchresult.IndividualSearchResult;
import freemarker.template.Configuration;
/** /**
* Paged search controller that uses Solr * Paged search controller that uses Solr
@ -104,12 +103,11 @@ public class PagedSearchController extends FreemarkerHttpServlet {
super.doGet(vreq,response); super.doGet(vreq,response);
}else{ }else{
try { try {
Configuration config = getConfig(vreq);
ResponseValues rvalues = processRequest(vreq); ResponseValues rvalues = processRequest(vreq);
response.setCharacterEncoding("UTF-8"); response.setCharacterEncoding("UTF-8");
response.setContentType("text/xml;charset=UTF-8"); response.setContentType("text/xml;charset=UTF-8");
writeTemplate(rvalues.getTemplateName(), rvalues.getMap(), config, request, response); writeTemplate(rvalues.getTemplateName(), rvalues.getMap(), request, response);
} catch (Exception e) { } catch (Exception e) {
log.error(e, e); log.error(e, e);
} }

34
webapp/src/edu/cornell/mannlib/vitro/webapp/search/solr/ExcludeBasedOnNamespace.java Normal file
View file

@ -0,0 +1,34 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.search.solr;
import java.util.Arrays;
import java.util.List;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
/**
* Skip individual if its URI is from any of the excludeNamepsaces
*
*/
public class ExcludeBasedOnNamespace implements SearchIndexExcluder {
List<String> excludeNamepsaces;
public ExcludeBasedOnNamespace(String ... excludeNamepsaces) {
super();
this.excludeNamepsaces = Arrays.asList(excludeNamepsaces);
}
@Override
public String checkForExclusion(Individual ind) {
for( String ns: excludeNamepsaces){
if( ns.equals( ind.getNamespace() ) ){
return "skipping because of namespace " ;
}
}
return null;
}
}

60
webapp/src/edu/cornell/mannlib/vitro/webapp/search/solr/ExcludeBasedOnType.java Normal file
View file

@ -0,0 +1,60 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.search.solr;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
/**
* Exclude individual from search index if
* it is a member of any of the the types.
* @author bdc34
*
*/
public class ExcludeBasedOnType implements SearchIndexExcluder {
List<String> typeURIs;
public ExcludeBasedOnType(String ... typeURIs) {
setExcludedTypes( typeURIs );
}
@Override
public String checkForExclusion(Individual ind) {
if( ind != null ) {
List<VClass> vclasses = ind.getVClasses();
if( vclasses != null && ! Collections.disjoint(vclasses, typeURIs) ){
return("skipping due to type.");
}
}
return null;
}
public void setExcludedTypes(String ... typeURIs){
setExcludedTypes(Arrays.asList(typeURIs));
}
public void setExcludedTypes(List<String> typeURIs){
synchronized(this){
this.typeURIs = new ArrayList<String>(typeURIs);
}
}
protected void addTypeToExclude(String typeURI){
if( typeURI != null && !typeURI.isEmpty()){
synchronized(this){
typeURIs.add(typeURI);
}
}
}
protected void removeTypeToExclude(String typeURI){
synchronized(this){
typeURIs.remove(typeURI);
}
}
}

58
webapp/src/edu/cornell/mannlib/vitro/webapp/search/solr/ExcludeBasedOnTypeNamespace.java Normal file
View file

@ -0,0 +1,58 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.search.solr;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.solr.common.SolrInputDocument;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
/**
* Exclude individuals based on the namespaces of their types.
*/
public class ExcludeBasedOnTypeNamespace implements SearchIndexExcluder {
final List<String> namespaces;
Pattern nsRegexPattern;
public ExcludeBasedOnTypeNamespace(String ... namespaces) {
super();
this.namespaces = Collections.unmodifiableList(Arrays.asList( namespaces ));
String nsOrPattern = "";
for( int i=0; i<namespaces.length; i++){
String ns = namespaces[i];
nsOrPattern = nsOrPattern + (i!=0?"|":"") + Pattern.quote(ns) + "[^/#]*$";
}
this.nsRegexPattern = Pattern.compile(nsOrPattern);
}
@Override
public String checkForExclusion(Individual ind) {
if( ind != null && ind.getVClasses() != null ){
for( VClass vclass : ind.getVClasses() ){
String excludeMsg = checkForSkip(ind, vclass);
if(excludeMsg != null)
return excludeMsg;
}
}
return null;
}
String checkForSkip(Individual individual, VClass vclass) {
if( vclass != null && vclass.getURI() != null ){
Matcher match=nsRegexPattern.matcher( vclass.getURI() );
if( match.matches() ){
return "Skipping because it is of a type in an excluded namespace.";
}
}
return null;
}
}

44
webapp/src/edu/cornell/mannlib/vitro/webapp/search/solr/ExcludeNonFlagVitro.java Normal file
View file

@ -0,0 +1,44 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.search.solr;
import java.util.List;
import org.apache.solr.common.SolrInputDocument;
import edu.cornell.mannlib.vitro.webapp.beans.Individual;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
/**
* Exclude individuals with types from the Vitro namespace from the
* search index. (Other than old vitro Flag types).
*/
public class ExcludeNonFlagVitro implements SearchIndexExcluder {
@Override
public String checkForExclusion(Individual ind) {
if( ind != null && ind.getVClasses() != null ) {
String excludeMsg = skipIfVitro(ind, ind.getVClasses() );
if( excludeMsg != null)
return excludeMsg;
}
return null;
}
String skipIfVitro(Individual ind, List<VClass> vclasses) {
for( VClass type: vclasses ){
if( type != null && type.getURI() != null ){
String typeURI = type.getURI();
if(typeURI.startsWith( VitroVocabulary.vitroURI )
&& ! typeURI.startsWith(VitroVocabulary.vitroURI + "Flag") ){
return "Skipped " + ind.getURI()+" because in "
+ VitroVocabulary.vitroURI + " namespace";
}
}
}
return null;
}
}

135
webapp/src/edu/cornell/mannlib/vitro/webapp/search/solr/IndividualToSolrDocument.java
View file

@ -2,8 +2,6 @@
package edu.cornell.mannlib.vitro.webapp.search.solr; package edu.cornell.mannlib.vitro.webapp.search.solr;
import org.jsoup.Jsoup;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.Iterator; import java.util.Iterator;
@ -14,6 +12,7 @@ import org.apache.commons.logging.LogFactory;
import org.apache.solr.common.SolrDocument; import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrInputDocument; import org.apache.solr.common.SolrInputDocument;
import org.joda.time.DateTime; import org.joda.time.DateTime;
import org.jsoup.Jsoup;
import com.hp.hpl.jena.vocabulary.OWL; import com.hp.hpl.jena.vocabulary.OWL;
@ -26,7 +25,6 @@ import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.search.IndexingException; import edu.cornell.mannlib.vitro.webapp.search.IndexingException;
import edu.cornell.mannlib.vitro.webapp.search.VitroSearchTermNames; import edu.cornell.mannlib.vitro.webapp.search.VitroSearchTermNames;
import edu.cornell.mannlib.vitro.webapp.search.beans.ClassProhibitedFromSearch; import edu.cornell.mannlib.vitro.webapp.search.beans.ClassProhibitedFromSearch;
import edu.cornell.mannlib.vitro.webapp.search.beans.IndividualProhibitedFromSearch;
public class IndividualToSolrDocument { public class IndividualToSolrDocument {
@ -34,41 +32,27 @@ public class IndividualToSolrDocument {
public static VitroSearchTermNames term = new VitroSearchTermNames(); public static VitroSearchTermNames term = new VitroSearchTermNames();
protected static String entClassName = Individual.class.getName();
protected ClassProhibitedFromSearch classesProhibitedFromSearch;
protected IndividualProhibitedFromSearch individualProhibitedFromSearch;
protected final String label = "http://www.w3.org/2000/01/rdf-schema#label"; protected final String label = "http://www.w3.org/2000/01/rdf-schema#label";
protected List<DocumentModifier> documentModifiers = new ArrayList<DocumentModifier>(); protected List<DocumentModifier> documentModifiers = new ArrayList<DocumentModifier>();
public IndividualToSolrDocument( protected List<SearchIndexExcluder> excludes;
ClassProhibitedFromSearch classesProhibitedFromSearch,
IndividualProhibitedFromSearch individualProhibitedFromSearch){
this( classesProhibitedFromSearch, public IndividualToSolrDocument(List<SearchIndexExcluder> excludes, List<DocumentModifier> docModifiers){
individualProhibitedFromSearch, this.excludes = excludes;
Collections.EMPTY_LIST);
}
public IndividualToSolrDocument(
ClassProhibitedFromSearch classesProhibitedFromSearch,
IndividualProhibitedFromSearch individualProhibitedFromSearch,
List<DocumentModifier> docModifiers){
this.classesProhibitedFromSearch = classesProhibitedFromSearch;
this.individualProhibitedFromSearch = individualProhibitedFromSearch;
this.documentModifiers = docModifiers; this.documentModifiers = docModifiers;
} }
@SuppressWarnings("static-access") @SuppressWarnings("static-access")
public SolrInputDocument translate(Individual ind) throws IndexingException{ public SolrInputDocument translate(Individual ind) throws IndexingException{
try{ try{
log.debug("translating " + ind.getURI()); log.debug("translating " + ind.getURI());
checkForSkipBasedOnNS( ind );
String excludeMsg = checkExcludes( ind );
if( excludeMsg != DONT_EXCLUDE){
log.debug(excludeMsg);
return null;
}
SolrInputDocument doc = new SolrInputDocument(); SolrInputDocument doc = new SolrInputDocument();
@ -78,43 +62,29 @@ public class IndividualToSolrDocument {
//vitro id //vitro id
doc.addField(term.URI, ind.getURI()); doc.addField(term.URI, ind.getURI());
//java class
doc.addField(term.JCLASS, entClassName);
//Individual Label //Individual Label
addLabel( ind, doc ); addLabel( ind, doc );
//add classes, classgroups get if prohibied becasue of its class //add classes, classgroups get if prohibied becasue of its class
StringBuffer classPublicNames = new StringBuffer(""); StringBuffer classPublicNames = new StringBuffer("");
boolean prohibited = addClasses(ind, doc, classPublicNames); addClasses(ind, doc, classPublicNames);
//filter out class groups, owl:ObjectProperties etc..
if(individualProhibitedFromSearch.isIndividualProhibited( ind.getURI() )){
return null;
}
// collecting URIs and rdfs:labels of objects of statements // collecting URIs and rdfs:labels of objects of statements
StringBuffer objectNames = new StringBuffer(""); StringBuffer objectNames = new StringBuffer("");
StringBuffer addUri = new StringBuffer(""); StringBuffer addUri = new StringBuffer("");
addObjectPropertyText(ind, doc, objectNames, addUri); addObjectPropertyText(ind, doc, objectNames, addUri);
//add if the individual has a thumbnail or not.
addThumbnailExistance(ind, doc);
//time of index in millis past epoc //time of index in millis past epoc
doc.addField(term.INDEXEDTIME, new Long( (new DateTime()).getMillis() ) ); doc.addField(term.INDEXEDTIME, new Long( (new DateTime()).getMillis() ) );
if(!prohibited){
addAllText( ind, doc, classPublicNames, objectNames ); addAllText( ind, doc, classPublicNames, objectNames );
runAdditionalDocModifers(ind,doc,addUri);
//boost for entity //boost for entity
if(documentModifiers == null || documentModifiers.isEmpty() && if(ind.getSearchBoost() != null && ind.getSearchBoost() != 0) {
(ind.getSearchBoost() != null && ind.getSearchBoost() != 0)) {
doc.setDocumentBoost(ind.getSearchBoost()); doc.setDocumentBoost(ind.getSearchBoost());
} }
}
runAdditionalDocModifers(ind,doc,addUri);
return doc; return doc;
}catch(SkipIndividualException ex){ }catch(SkipIndividualException ex){
@ -122,7 +92,7 @@ public class IndividualToSolrDocument {
log.debug(ex); log.debug(ex);
return null; return null;
}catch(Throwable th){ }catch(Throwable th){
//Odd exceptions from jena get thrown on shutdown //Odd exceptions can get thrown on shutdown
if( log != null ) if( log != null )
log.debug(th); log.debug(th);
return null; return null;
@ -130,6 +100,19 @@ public class IndividualToSolrDocument {
} }
protected String checkExcludes(Individual ind) {
for( SearchIndexExcluder excluder : excludes){
try{
String msg = excluder.checkForExclusion(ind);
if( msg != DONT_EXCLUDE)
return msg;
}catch (Exception e) {
return e.getMessage();
}
}
return DONT_EXCLUDE;
}
protected void runAdditionalDocModifers( Individual ind, SolrInputDocument doc, StringBuffer addUri ) protected void runAdditionalDocModifers( Individual ind, SolrInputDocument doc, StringBuffer addUri )
throws SkipIndividualException{ throws SkipIndividualException{
//run the document modifiers //run the document modifiers
@ -140,18 +123,6 @@ public class IndividualToSolrDocument {
} }
} }
protected void checkForSkipBasedOnNS(Individual ind) throws SkipIndividualException {
String id = ind.getURI();
if(id == null){
throw new SkipIndividualException("cannot add individuals without URIs to search index");
}else if( id.startsWith(VitroVocabulary.vitroURI) ||
id.startsWith(VitroVocabulary.VITRO_PUBLIC) ||
id.startsWith(VitroVocabulary.PSEUDO_BNODE_NS) ||
id.startsWith(OWL.NS)){
throw new SkipIndividualException("not indexing because of namespace:" + id);
}
}
protected void addAllText(Individual ind, SolrInputDocument doc, StringBuffer classPublicNames, StringBuffer objectNames) { protected void addAllText(Individual ind, SolrInputDocument doc, StringBuffer classPublicNames, StringBuffer objectNames) {
String t=null; String t=null;
//ALLTEXT, all of the 'full text' //ALLTEXT, all of the 'full text'
@ -210,19 +181,7 @@ public class IndividualToSolrDocument {
// NAME_LOWERCASE, NAME_UNSTEMMED, NAME_STEMMED, NAME_PHONETIC, AC_NAME_UNTOKENIZED, AC_NAME_STEMMED // NAME_LOWERCASE, NAME_UNSTEMMED, NAME_STEMMED, NAME_PHONETIC, AC_NAME_UNTOKENIZED, AC_NAME_STEMMED
} }
/**
* Adds if the individual has a thumbnail image or not.
*/
protected void addThumbnailExistance(Individual ind, SolrInputDocument doc) {
try{
if(ind.hasThumb())
doc.addField(term.THUMBNAIL, "1");
else
doc.addField(term.THUMBNAIL, "0");
}catch(Exception ex){
log.debug("could not index thumbnail: " + ex);
}
}
/** /**
* Get the rdfs:labes for objects of statements and put in objectNames. * Get the rdfs:labes for objects of statements and put in objectNames.
@ -258,32 +217,24 @@ public class IndividualToSolrDocument {
* @returns true if prohibited from search * @returns true if prohibited from search
* @throws SkipIndividualException * @throws SkipIndividualException
*/ */
protected boolean addClasses(Individual ind, SolrInputDocument doc, StringBuffer classPublicNames) throws SkipIndividualException{ protected void addClasses(Individual ind, SolrInputDocument doc, StringBuffer classPublicNames) throws SkipIndividualException{
ArrayList<String> superClassNames = null; ArrayList<String> superClassNames = null;
// Types and classgroups
boolean prohibited = false;
List<VClass> vclasses = ind.getVClasses(false); List<VClass> vclasses = ind.getVClasses(false);
superClassNames = new ArrayList<String>(); if( vclasses == null || vclasses.isEmpty() ){
throw new SkipIndividualException("Not indexing because individual has no super classes");
}
for(VClass clz : vclasses){ for(VClass clz : vclasses){
String superLclName = clz.getLocalName();
superClassNames.add(superLclName);
if(clz.getURI() == null){ if(clz.getURI() == null){
continue; continue;
}else if(OWL.Thing.getURI().equals(clz.getURI())){ }else if(OWL.Thing.getURI().equals(clz.getURI())){
//index individuals of type owl:Thing, just don't add owl:Thing as the type field in the index //don't add owl:Thing as the type in the index
continue; continue;
} else if(clz.getURI().startsWith(OWL.NS)){
throw new SkipIndividualException("not indexing " + ind.getURI() + " because of type " + clz.getURI() );
}
// do not index individuals of type Role, AdvisingRelationShip, Authorship, etc.(see search.n3 for more information)
else if(classesProhibitedFromSearch.isClassProhibitedFromSearch(clz.getURI())){
throw new SkipIndividualException("not indexing " + ind.getURI() + " because of prohibited type " + clz.getURI() );
} else { } else {
if( !prohibited && classesProhibitedFromSearch.isClassProhibitedFromSearch(clz.getURI())) if( clz.getSearchBoost() != null){
prohibited = true;
if( clz.getSearchBoost() != null)
doc.setDocumentBoost(doc.getDocumentBoost() + clz.getSearchBoost()); doc.setDocumentBoost(doc.getDocumentBoost() + clz.getSearchBoost());
}
doc.addField(term.RDFTYPE, clz.getURI()); doc.addField(term.RDFTYPE, clz.getURI());
@ -303,13 +254,6 @@ public class IndividualToSolrDocument {
} }
} }
} }
if(superClassNames.isEmpty()){
throw new SkipIndividualException("Not indexing because individual has no super classes");
}
doc.addField(term.PROHIBITED_FROM_TEXT_RESULTS, prohibited?"1":"0");
return prohibited;
} }
public Object getIndexId(Object obj) { public Object getIndexId(Object obj) {
@ -318,7 +262,7 @@ public class IndividualToSolrDocument {
public String getIdForUri(String uri){ public String getIdForUri(String uri){
if( uri != null ){ if( uri != null ){
return entClassName + uri; return "vitroIndividual:" + uri;
}else{ }else{
return null; return null;
} }
@ -352,6 +296,5 @@ public class IndividualToSolrDocument {
} }
} }
public static float NAME_BOOST = 1.2F; protected static final String DONT_EXCLUDE =null;
} }

20
webapp/src/edu/cornell/mannlib/vitro/webapp/search/solr/NameBoost.java
View file

@ -10,10 +10,21 @@ import edu.cornell.mannlib.vitro.webapp.search.VitroSearchTermNames;
public class NameBoost implements DocumentModifier { public class NameBoost implements DocumentModifier {
static VitroSearchTermNames term = new VitroSearchTermNames(); /**
* These are the fields in the solr Document that
* are related to the name. If you modify the schema,
* please consider if you need to change this list
* of name fields to boost.
*/
static final VitroSearchTermNames term = new VitroSearchTermNames();
String[] fieldsToBoost = {term.NAME_RAW,term.NAME_LOWERCASE,term.NAME_UNSTEMMED,term.NAME_STEMMED}; String[] fieldsToBoost = {term.NAME_RAW,term.NAME_LOWERCASE,term.NAME_UNSTEMMED,term.NAME_STEMMED};
static final float NAME_BOOST = (float) 1.2;
final float boost;
public NameBoost(float boost){
this.boost = boost;
}
@Override @Override
public void modifyDocument(Individual individual, SolrInputDocument doc, public void modifyDocument(Individual individual, SolrInputDocument doc,
@ -21,8 +32,9 @@ public class NameBoost implements DocumentModifier {
for( String fieldName : fieldsToBoost){ for( String fieldName : fieldsToBoost){
SolrInputField field = doc.getField(fieldName); SolrInputField field = doc.getField(fieldName);
if( field != null ) if( field != null ){
field.setBoost(field.getBoost() * NAME_BOOST); field.setBoost(field.getBoost() + boost);
}
} }
} }

Some files were not shown because too many files have changed in this diff Show more