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

Merge remote-tracking branch 'origin/develop' into dev-isf

Browse source 
Conflicts:
	webapp/src/edu/cornell/mannlib/vitro/webapp/filestorage/uploadrequest/MultipartHttpServletRequest.java
This commit is contained in:
brianjlowe 2013-08-06 11:05:54 -04:00
commit a270043063
39 changed files with 1313 additions and 2278 deletions
Download patch file Download diff file Expand all files Collapse all files

1036
webapp/build.xml
View file

File diff suppressed because it is too large Load diff

11
webapp/src/edu/cornell/mannlib/vitro/webapp/auth/permissions/SimplePermission.java
View file

@ -74,6 +74,15 @@ public class SimplePermission extends Permission {
"SeeVerbosePropertyInformation");
public static final SimplePermission USE_ADVANCED_DATA_TOOLS_PAGES = new SimplePermission(
"UseAdvancedDataToolsPages");
public static final SimplePermission USE_SPARQL_QUERY_PAGE = new SimplePermission(
"UseSparqlQueryPage");
// ----------------------------------------------------------------------
// These instances are "catch all" permissions to cover poorly defined
// groups of actions until better definitions were found. Don't add usages
// of these, and remove existing usages where possible.
// ----------------------------------------------------------------------
public static final SimplePermission USE_BASIC_AJAX_CONTROLLERS = new SimplePermission(
"UseBasicAjaxControllers");
public static final SimplePermission USE_MISCELLANEOUS_ADMIN_PAGES = new SimplePermission(
@ -84,8 +93,6 @@ public class SimplePermission extends Permission {
"UseMiscellaneousEditorPages");
public static final SimplePermission USE_MISCELLANEOUS_PAGES = new SimplePermission(
"UseMiscellaneousPages");
public static final SimplePermission USE_SPARQL_QUERY_PAGE = new SimplePermission(
"UseSparqlQueryPage");
public static List<SimplePermission> getAllInstances() {
return new ArrayList<SimplePermission>(allInstances.values());

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

@ -5,6 +5,7 @@ package edu.cornell.mannlib.vitro.webapp.controller.freemarker;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
@ -28,6 +29,8 @@ import edu.cornell.mannlib.vitro.webapp.i18n.freemarker.I18nMethodModel;
import edu.cornell.mannlib.vitro.webapp.utils.dataGetter.DataGetter;
import edu.cornell.mannlib.vitro.webapp.utils.dataGetter.DataGetterUtils;
import edu.cornell.mannlib.vitro.webapp.web.directives.IndividualShortViewDirective;
import edu.cornell.mannlib.vitro.webapp.web.directives.UrlDirective;
import edu.cornell.mannlib.vitro.webapp.web.directives.WidgetDirective;
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.IndividualProfileUrlMethod;
@ -166,16 +169,20 @@ public class FreemarkerConfiguration extends Configuration {
return urls;
}
public static Map<String, Object> getDirectives() {
private static Map<String, Object> getDirectives() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("dump", new freemarker.ext.dump.DumpDirective());
map.put("dumpAll", new freemarker.ext.dump.DumpAllDirective());
map.put("help", new freemarker.ext.dump.HelpDirective());
map.put("shortView", new IndividualShortViewDirective());
map.put("url", new UrlDirective());
map.put("widget", new WidgetDirective());
return map;
}
public static Map<String, Object> getMethods() {
private static Map<String, Object> getMethods() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("profileUrl", new IndividualProfileUrlMethod());
map.put("localName", new IndividualLocalNameMethod());
@ -319,4 +326,54 @@ public class FreemarkerConfiguration extends Configuration {
}
}
// ----------------------------------------------------------------------
// Request info and overrides
// ----------------------------------------------------------------------
private ThreadLocal<FreemarkerRequestInfo> reqInfo = new ThreadLocal<>();
void setRequestInfo(HttpServletRequest req) {
reqInfo.set(new FreemarkerRequestInfo(req));
}
@Override
public Object getCustomAttribute(String name) {
if ("request".equals(name)) {
return reqInfo.get().getRequest();
} else {
return super.getCustomAttribute(name);
}
}
@Override
public String[] getCustomAttributeNames() {
String[] nameArray = super.getCustomAttributeNames();
Set<String> nameSet = new HashSet<String>(Arrays.asList(nameArray));
nameSet.add("request");
return nameSet.toArray(new String[nameSet.size()]);
}
@Override
public Locale getLocale() {
return reqInfo.get().getLocale();
}
public static class FreemarkerRequestInfo {
private final HttpServletRequest req;
public FreemarkerRequestInfo(HttpServletRequest req) {
this.req = req;
}
public HttpServletRequest getRequest() {
return req;
}
public Locale getLocale() {
return req.getLocale();
}
}
}

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

@ -21,7 +21,9 @@ public class FreemarkerConfigurationLoader {
public static FreemarkerConfiguration getConfig(VitroRequest vreq) {
String themeDir = getThemeDir(vreq.getAppBean());
return getConfigForTheme(themeDir, vreq.getAppBean(), vreq.getSession().getServletContext());
FreemarkerConfiguration config = getConfigForTheme(themeDir, vreq.getAppBean(), vreq.getSession().getServletContext());
config.setRequestInfo(vreq);
return config;
}
private static String getThemeDir(ApplicationBean appBean) {

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

@ -427,10 +427,6 @@ public class FreemarkerHttpServlet extends VitroHttpServlet {
// the copyright text can be viewed with having to restart Tomcat
map.put("copyright", getCopyrightInfo(appBean));
map.put("url", new edu.cornell.mannlib.vitro.webapp.web.directives.UrlDirective());
map.put("widget", new edu.cornell.mannlib.vitro.webapp.web.directives.WidgetDirective());
map.putAll( FreemarkerConfiguration.getDirectives() );
// Add these accumulator objects. They will collect tags so the template can write them
// at the appropriate location.
map.put("stylesheets", new Tags().wrap());

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

@ -24,13 +24,9 @@ public class TemplateProcessingHelper {
private static final Log log = LogFactory.getLog(TemplateProcessingHelper.class);
private Configuration config = null;
private HttpServletRequest request = null;
private ServletContext context = null;
public TemplateProcessingHelper(HttpServletRequest request, ServletContext context) {
this.config = FreemarkerConfigurationLoader.getConfig(new VitroRequest(request));
this.request = request;
this.context = context;
}
public StringWriter processTemplate(String templateName, Map<String, Object> map)
@ -46,14 +42,6 @@ public class TemplateProcessingHelper {
try {
Environment env = template.createProcessingEnvironment(map, writer);
// Add request and servlet context as custom attributes of the environment, so they
// can be used in directives.
env.setCustomAttribute("request", request);
env.setCustomAttribute("context", context);
// Set the Locale from the request into the environment, so date builtins will be
// Locale-dependent
env.setLocale(request.getLocale());
// Define a setup template to be included by every page template
String templateType = (String) map.get("templateType");

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

@ -1,39 +0,0 @@
/* $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;
}
}

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

@ -3,8 +3,11 @@
package edu.cornell.mannlib.vitro.webapp.controller.json;
import java.io.IOException;
import java.net.URLEncoder;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.Map;
@ -15,17 +18,21 @@ import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONArray;
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.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.controller.Controllers;
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.controller.freemarker.IndividualListController.PageRecord;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.UrlBuilder;
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.
@ -69,7 +76,9 @@ public class JsonServlet extends VitroHttpServlet {
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);
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 Aug 5th 2013.");
}else if( vreq.getParameter("getRenderedSolrIndividualsByVClass") != null ){
new GetRenderedSolrIndividualsByVClass(vreq).process(resp);
}else if( vreq.getParameter("getRandomSolrIndividualsByVClass") != null ){
@ -85,7 +94,7 @@ public class JsonServlet extends VitroHttpServlet {
Map<String, Object> map = getSolrVClassIntersectionResults(vclassURIs, vreq, context);
//last parameter indicates single vclass instead of multiple vclasses
return processVClassResults(map, vreq, context, false);
return processVclassResultsJSON(map, vreq, false);
}
public static JSONObject getSolrIndividualsByVClasses(List<String> vclassURIs, HttpServletRequest req, ServletContext context) throws Exception {
@ -93,8 +102,8 @@ public class JsonServlet extends VitroHttpServlet {
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;
return processVclassResultsJSON(map, vreq, true);
}
//Including version for Solr query for Vclass Intersections
@ -119,10 +128,10 @@ public class JsonServlet extends VitroHttpServlet {
}
// 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 JSONObject processVClassResults(Map<String, Object> map, VitroRequest vreq, ServletContext context, boolean multipleVclasses) throws Exception{
// JSONObject rObj = processVclassResultsJSON(map, vreq, multipleVclasses);
// return rObj;
// }
public static Collection<String> getMostSpecificTypes(Individual individual, WebappDaoFactory wdf) {
ObjectPropertyStatementDao opsDao = wdf.getObjectPropertyStatementDao();
@ -143,7 +152,7 @@ public class JsonServlet extends VitroHttpServlet {
Map<String, Object> map = getRandomSolrVClassResults(vclassURI, vreq, context);
//last parameter indicates single vclass instead of multiple vclasses
return processVClassResults(map, vreq, context, false);
return processVclassResultsJSON(map, vreq, false);
}
//Including version for Random Solr query for Vclass Intersections
@ -169,4 +178,120 @@ public class JsonServlet extends VitroHttpServlet {
}
/**
* Process results related to VClass or vclasses. Handles both single and multiple vclasses being sent.
*/
public static JSONObject processVclassResultsJSON(Map<String, Object> map, VitroRequest vreq, boolean multipleVclasses) {
JSONObject rObj = new JSONObject();
VClass vclass=null;
try {
// Properties from ontologies used by VIVO - should not be in vitro
DataProperty fNameDp = (new DataProperty());
fNameDp.setURI("http://xmlns.com/foaf/0.1/firstName");
DataProperty lNameDp = (new DataProperty());
lNameDp.setURI("http://xmlns.com/foaf/0.1/lastName");
DataProperty preferredTitleDp = (new DataProperty());
preferredTitleDp.setURI("http://vivoweb.org/ontology/core#preferredTitle");
if( log.isDebugEnabled() ){
@SuppressWarnings("unchecked")
Enumeration<String> e = vreq.getParameterNames();
while(e.hasMoreElements()){
String name = e.nextElement();
log.debug("parameter: " + name);
for( String value : vreq.getParameterValues(name) ){
log.debug("value for " + name + ": '" + value + "'");
}
}
}
//need an unfiltered dao to get firstnames and lastnames
WebappDaoFactory fullWdf = vreq.getUnfilteredWebappDaoFactory();
String[] vitroClassIdStr = vreq.getParameterValues("vclassId");
if ( vitroClassIdStr != null && vitroClassIdStr.length > 0){
for(String vclassId: vitroClassIdStr) {
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 ");
throw new Exception("parameter vclassId URI parameter expected ");
}
List<String> vclassIds = Arrays.asList(vitroClassIdStr);
//if single vclass expected, then include vclass. This relates to what the expected behavior is, not size of list
if(!multipleVclasses) {
//currently used for ClassGroupPage
rObj.put("vclass",
new JSONObject().put("URI",vclass.getURI())
.put("name",vclass.getName()));
} else {
//For now, utilize very last VClass (assume that that is the one to be employed)
//TODO: Find more general way of dealing with this
//put multiple ones in?
if(vclassIds.size() > 0) {
int numberVClasses = vclassIds.size();
vclass = vreq.getWebappDaoFactory().getVClassDao().getVClassByURI(vclassIds.get(numberVClasses - 1));
rObj.put("vclass", new JSONObject().put("URI",vclass.getURI())
.put("name",vclass.getName()));
}
// rObj.put("vclasses", new JSONObject().put("URIs",vitroClassIdStr)
// .put("name",vclass.getName()));
}
if (vclass != null) {
rObj.put("totalCount", map.get("totalCount"));
rObj.put("alpha", map.get("alpha"));
List<Individual> inds = (List<Individual>)map.get("entities");
log.debug("Number of individuals returned from request: " + inds.size());
JSONArray jInds = new JSONArray();
for(Individual ind : inds ){
JSONObject jo = new JSONObject();
jo.put("URI", ind.getURI());
jo.put("label",ind.getRdfsLabel());
jo.put("name",ind.getName());
jo.put("thumbUrl", ind.getThumbUrl());
jo.put("imageUrl", ind.getImageUrl());
jo.put("profileUrl", UrlBuilder.getIndividualProfileUrl(ind, vreq));
jo.put("mostSpecificTypes", JsonServlet.getMostSpecificTypes(ind,fullWdf));
jo.put("preferredTitle", JsonServlet.getDataPropertyValue(ind, preferredTitleDp, fullWdf));
jInds.put(jo);
}
rObj.put("individuals", jInds);
JSONArray wpages = new JSONArray();
//Made sure that PageRecord here is SolrIndividualListController not IndividualListController
List<PageRecord> pages = (List<PageRecord>)map.get("pages");
for( PageRecord pr: pages ){
JSONObject p = new JSONObject();
p.put("text", pr.text);
p.put("param", pr.param);
p.put("index", pr.index);
wpages.put( p );
}
rObj.put("pages",wpages);
JSONArray jletters = new JSONArray();
List<String> letters = Controllers.getLetters();
for( String s : letters){
JSONObject jo = new JSONObject();
jo.put("text", s);
jo.put("param", "alpha=" + URLEncoder.encode(s, "UTF-8"));
jletters.put( jo );
}
rObj.put("letters", jletters);
}
} catch(Exception ex) {
log.error("Error occurred in processing JSON object", ex);
}
return rObj;
}
}

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

@ -30,8 +30,6 @@ import org.apache.commons.logging.LogFactory;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.FreemarkerConfiguration;
import edu.cornell.mannlib.vitro.webapp.web.directives.EmailDirective;
import freemarker.core.Environment;
import freemarker.template.Template;
import freemarker.template.TemplateException;
/**
@ -144,14 +142,8 @@ public class FreemarkerEmailMessage {
bodyMap.put("email", new EmailDirective(this));
try {
Template template = config.getTemplate(templateName);
Environment env = template.createProcessingEnvironment(bodyMap,
config.getTemplate(templateName).process(bodyMap,
new StringWriter());
env.setCustomAttribute("request", vreq);
env.setCustomAttribute("context", vreq.getSession()
.getServletContext());
env.process();
} catch (TemplateException e) {
log.error(e, e);
} catch (IOException e) {

220
webapp/src/edu/cornell/mannlib/vitro/webapp/filestorage/uploadrequest/FileUploadServletRequest.java
View file

@ -3,8 +3,15 @@
package edu.cornell.mannlib.vitro.webapp.filestorage.uploadrequest;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
@ -12,6 +19,8 @@ import javax.servlet.http.HttpServletRequestWrapper;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* <p>
@ -44,21 +53,39 @@ import org.apache.commons.fileupload.servlet.ServletFileUpload;
*/
@SuppressWarnings("deprecation")
public abstract class FileUploadServletRequest extends HttpServletRequestWrapper {
private static final Log log = LogFactory
.getLog(FileUploadServletRequest.class);
public static final String FILE_ITEM_MAP = "file_item_map";
public static final String FILE_UPLOAD_EXCEPTION = "file_upload_exception";
private Map<String, List<String>> parameters;
private Map<String, List<FileItem>> files;
private FileUploadException fileUploadException;
private static final String[] EMPTY_ARRAY = new String[0];
// ----------------------------------------------------------------------
// The factory method
// ----------------------------------------------------------------------
/**
* Wrap this {@link HttpServletRequest} in an appropriate wrapper class.
* set maxTempFileSize to 0 or -1 if streaming is desired. Set it to > 0 if
* you want any parts uploaded to a temporary directory
*/
public static FileUploadServletRequest parseRequest(
HttpServletRequest request, int maxFileSize) throws IOException {
public static FileUploadServletRequest parseRequest(
HttpServletRequest request, int maxTempFileSize) throws IOException {
boolean isMultipart = ServletFileUpload.isMultipartContent(request);
if (isMultipart) {
return new MultipartHttpServletRequest(request, maxFileSize);
if( maxTempFileSize <= 0 ){
return new StreamingMultipartHttpServletRequest(request);
}else{
return new MultipartHttpServletRequest(request, maxTempFileSize);
}
} else {
return new SimpleHttpServletRequestWrapper(request);
}
@ -85,29 +112,184 @@ public abstract class FileUploadServletRequest extends HttpServletRequestWrapper
/** Was this a multipart HTTP request? */
public abstract boolean isMultipart();
protected void stashParametersInRequest(HttpServletRequest request, ServletFileUpload upload){
Map<String, List<String>> parameters = new HashMap<String, List<String>>();
Map<String, List<FileItem>> files = new HashMap<String, List<FileItem>>();
parseQueryString(request.getQueryString(), parameters);
try {
List<FileItem> items = upload.parseRequest( request );
for (FileItem item : items) {
// Process a regular form field
if (item.isFormField()) {
addToParameters(parameters, item.getFieldName(), item
.getString("UTF-8"));
log.debug("Form field (parameter) " + item.getFieldName()
+ "=" + item.getString());
} else {
addToFileItems(files, item);
log.debug("File " + item.getFieldName() + ": "
+ item.getName());
}
}
} catch (FileUploadException e) {
fileUploadException = e;
request.setAttribute(
FileUploadServletRequest.FILE_UPLOAD_EXCEPTION, e);
} catch (UnsupportedEncodingException e) {
log.error("could not convert to UTF-8",e);
}
this.parameters = Collections.unmodifiableMap(parameters);
log.debug("Parameters are: " + this.parameters);
this.files = Collections.unmodifiableMap(files);
log.debug("Files are: " + this.files);
request.setAttribute(FILE_ITEM_MAP, this.files);
}
/**
* Get the map of file items, by name.
* Pull any parameters out of the URL.
*/
public abstract Map<String, List<FileItem>> getFiles();
private void parseQueryString(String queryString,
Map<String, List<String>> parameters) {
log.debug("Query string is : '" + queryString + "'");
if (queryString != null) {
String[] pieces = queryString.split("&");
for (String piece : pieces) {
int equalsHere = piece.indexOf('=');
if (piece.trim().isEmpty()) {
// Ignore an empty piece.
} else if (equalsHere <= 0) {
// A parameter without a value.
addToParameters(parameters, decode(piece), "");
} else {
// A parameter with a value.
String key = piece.substring(0, equalsHere);
String value = piece.substring(equalsHere + 1);
addToParameters(parameters, decode(key), decode(value));
}
}
}
log.debug("Parameters from query string are: " + parameters);
}
/**
* Find a non-empty file item with this name.
*
* @return the first such file item, or <code>null</code> if no matching,
* non-empty items were found.
* Remove any special URL-style encoding.
*/
public abstract FileItem getFileItem(String string);
private String decode(String encoded) {
try {
return URLDecoder.decode(encoded, "UTF-8");
} catch (UnsupportedEncodingException e) {
log.error(e, e);
return encoded;
}
}
/**
* Was there an exception when uploading the file items?
*/
public abstract boolean hasFileUploadException();
/**
* Get the exception that occurred when uploading the file items. If no such
* exception, return <code>null</code>.
*/
public abstract FileUploadException getFileUploadException();
/** Either create a new List for the value, or add to an existing List. */
private void addToParameters(Map<String, List<String>> map, String name,
String value) {
if (!map.containsKey(name)) {
map.put(name, new ArrayList<String>());
}
map.get(name).add(value);
}
/** Either create a new List for the file, or add to an existing List. */
private void addToFileItems(Map<String, List<FileItem>> map, FileItem file) {
String name = file.getFieldName();
if (!map.containsKey(name)) {
map.put(name, new ArrayList<FileItem>());
}
map.get(name).add(file);
}
public FileUploadException getFileUploadException() {
return fileUploadException;
}
public boolean hasFileUploadException() {
return fileUploadException != null;
}
// ----------------------------------------------------------------------
// Parameter-related methods won't find anything on the delegate request,
// since parsing consumed the parameters. So we need to look to the parsed
// info for the answers.
// ----------------------------------------------------------------------
@Override
public String getParameter(String name) {
if (parameters.containsKey(name)) {
return parameters.get(name).get(0);
} else {
return null;
}
}
@Override
public Enumeration<?> getParameterNames() {
return Collections.enumeration(parameters.keySet());
}
@Override
public String[] getParameterValues(String name) {
if (parameters.containsKey(name)) {
return parameters.get(name).toArray(EMPTY_ARRAY);
} else {
return null;
}
}
@Override
public Map<String, String[]> getParameterMap() {
Map<String, String[]> result = new HashMap<String, String[]>();
for (Entry<String, List<String>> entry : parameters.entrySet()) {
result.put(entry.getKey(), entry.getValue().toArray(EMPTY_ARRAY));
}
log.debug("resulting parameter map: " + result);
return result;
}
/**
* {@inheritDoc}
* <p>
* There may be more than one file item with the given name. If the first
* one is empty (size is zero), keep looking for a non-empty one.
* </p>
*/
public FileItem getFileItem(String name) {
List<FileItem> items = files.get(name);
if (items == null) {
return null;
}
for (FileItem item : items) {
if (item.getSize() > 0L) {
return item;
}
}
return null;
}
/**
* Gets a map of parameter names to files.
* This will should return null.
*/
public Map<String, List<FileItem>> getFiles() {
if( files == null )
return Collections.emptyMap();
else
return files;
}
}

244
webapp/src/edu/cornell/mannlib/vitro/webapp/filestorage/uploadrequest/MultipartHttpServletRequest.java
View file

@ -33,33 +33,8 @@ public class MultipartHttpServletRequest extends FileUploadServletRequest {
private static final Log log = LogFactory
.getLog(MultipartHttpServletRequest.class);
private static final String[] EMPTY_ARRAY = new String[0];
private Map<String, List<String>> parameters;
private Map<String, List<FileItem>> files;
private FileUploadException fileUploadException;
private boolean storeFilesToTempDir = false;
private int maxFileSize = 0;
private File tempDir = null;
/**
* Parse the multipart request. Store the info about the request parameters.
* Don't store the uploaded files to a temporary directory to allow streaming.
*
* Only use this constructor if you plan to consume the FileItems using streaming
* to deal with inputs of very large sizes.
*
* In all other case you should use the maxFileSize constructor to deal with
* the size of the uploaded file in a safe way.
*/
public MultipartHttpServletRequest(HttpServletRequest request)
throws IOException{
super(request);
storeFilesToTempDir = false;
setup(request);
}
private File tempDir = null;
/**
* Parse the multipart request. Store the info about the request parameters
@ -71,93 +46,16 @@ public class MultipartHttpServletRequest extends FileUploadServletRequest {
public MultipartHttpServletRequest(HttpServletRequest request,
int maxFileSize) throws IOException {
super(request);
storeFilesToTempDir = true;
this.maxFileSize = maxFileSize;
this.tempDir = figureTemporaryDirectory(request);
setup(request);
}
private void setup(HttpServletRequest request){
Map<String, List<String>> parameters = new HashMap<String, List<String>>();
Map<String, List<FileItem>> files = new HashMap<String, List<FileItem>>();
ServletFileUpload upload = createUploadHandler();
//File tempDir = figureTemporaryDirectory(request);
//ServletFileUpload upload = createUploadHandler(maxFileSize, tempDir);
parseQueryString(request.getQueryString(), parameters);
try {
List<FileItem> items = parseRequestIntoFileItems(request, upload);
for (FileItem item : items) {
// Process a regular form field
if (item.isFormField()) {
addToParameters(parameters, item.getFieldName(), item
.getString("UTF-8"));
log.debug("Form field (parameter) " + item.getFieldName()
+ "=" + item.getString());
} else {
addToFileItems(files, item);
log.debug("File " + item.getFieldName() + ": "
+ item.getName());
}
}
} catch (FileUploadException e) {
fileUploadException = e;
request.setAttribute(
FileUploadServletRequest.FILE_UPLOAD_EXCEPTION, e);
} catch (UnsupportedEncodingException e) {
log.error("could not convert to UTF-8",e);
}
this.parameters = Collections.unmodifiableMap(parameters);
log.debug("Parameters are: " + this.parameters);
this.files = Collections.unmodifiableMap(files);
log.debug("Files are: " + this.files);
request.setAttribute(FILE_ITEM_MAP, this.files);
}
/**
* Pull any parameters out of the URL.
*/
private void parseQueryString(String queryString,
Map<String, List<String>> parameters) {
log.debug("Query string is : '" + queryString + "'");
if (queryString != null) {
String[] pieces = queryString.split("&");
for (String piece : pieces) {
int equalsHere = piece.indexOf('=');
if (piece.trim().isEmpty()) {
// Ignore an empty piece.
} else if (equalsHere <= 0) {
// A parameter without a value.
addToParameters(parameters, decode(piece), "");
} else {
// A parameter with a value.
String key = piece.substring(0, equalsHere);
String value = piece.substring(equalsHere + 1);
addToParameters(parameters, decode(key), decode(value));
}
}
}
log.debug("Parameters from query string are: " + parameters);
}
/**
* Remove any special URL-style encoding.
*/
private String decode(String encoded) {
try {
return URLDecoder.decode(encoded, "UTF-8");
} catch (UnsupportedEncodingException e) {
log.error(e, e);
return encoded;
}
//use an upload handler that will stash the file items in a temporary directory.
ServletFileUpload upload = createUploadHandler( this.maxFileSize, this.tempDir );
stashParametersInRequest( request , upload );
}
/**
* Find the temporary storage directory for this webapp.
*/
@ -165,19 +63,7 @@ public class MultipartHttpServletRequest extends FileUploadServletRequest {
return (File) request.getSession().getServletContext().getAttribute(
"javax.servlet.context.tempdir");
}
/**
* Create an upload handler based on this.storeFilesToTempDir.
*/
private ServletFileUpload createUploadHandler(){
if( storeFilesToTempDir ){
return createUploadHandler( this.maxFileSize, this.tempDir );
}else{
return new ServletFileUpload();
}
}
/**
* Create an upload handler that will throw an exception if the file is too
* large.
@ -193,116 +79,10 @@ public class MultipartHttpServletRequest extends FileUploadServletRequest {
return upload;
}
/** Either create a new List for the value, or add to an existing List. */
private void addToParameters(Map<String, List<String>> map, String name,
String value) {
if (!map.containsKey(name)) {
map.put(name, new ArrayList<String>());
}
map.get(name).add(value);
}
/** Either create a new List for the file, or add to an existing List. */
private void addToFileItems(Map<String, List<FileItem>> map, FileItem file) {
String name = file.getFieldName();
if (!map.containsKey(name)) {
map.put(name, new ArrayList<FileItem>());
}
map.get(name).add(file);
}
/** Minimize the code that uses the unchecked cast. */
@SuppressWarnings("unchecked")
private List<FileItem> parseRequestIntoFileItems(HttpServletRequest req,
ServletFileUpload upload) throws FileUploadException {
return upload.parseRequest(req);
}
// ----------------------------------------------------------------------
// This is a multipart request, so make the file info available. If there
// was an exception during parsing, make that available too.
// ----------------------------------------------------------------------
@Override
public boolean isMultipart() {
return true;
}
@Override
public Map<String, List<FileItem>> getFiles() {
return files;
}
/**
* {@inheritDoc}
* <p>
* There may be more than one file item with the given name. If the first
* one is empty (size is zero), keep looking for a non-empty one.
* </p>
*/
@Override
public FileItem getFileItem(String name) {
List<FileItem> items = files.get(name);
if (items == null) {
return null;
}
for (FileItem item : items) {
if (item.getSize() > 0L) {
return item;
}
}
return null;
}
@Override
public FileUploadException getFileUploadException() {
return fileUploadException;
}
@Override
public boolean hasFileUploadException() {
return fileUploadException != null;
}
// ----------------------------------------------------------------------
// Parameter-related methods won't find anything on the delegate request,
// since parsing consumed the parameters. So we need to look to the parsed
// info for the answers.
// ----------------------------------------------------------------------
@Override
public String getParameter(String name) {
if (parameters.containsKey(name)) {
return parameters.get(name).get(0);
} else {
return null;
}
}
@Override
public Enumeration<?> getParameterNames() {
return Collections.enumeration(parameters.keySet());
}
@Override
public String[] getParameterValues(String name) {
if (parameters.containsKey(name)) {
return parameters.get(name).toArray(EMPTY_ARRAY);
} else {
return null;
}
}
@Override
public Map<String, String[]> getParameterMap() {
Map<String, String[]> result = new HashMap<String, String[]>();
for (Entry<String, List<String>> entry : parameters.entrySet()) {
result.put(entry.getKey(), entry.getValue().toArray(EMPTY_ARRAY));
}
log.debug("resulting parameter map: " + result);
return result;
}
@Override
public boolean isMultipart() {
return true;
}
}

23
webapp/src/edu/cornell/mannlib/vitro/webapp/filestorage/uploadrequest/SimpleHttpServletRequestWrapper.java
View file

@ -33,26 +33,7 @@ class SimpleHttpServletRequestWrapper extends FileUploadServletRequest {
return false;
}
@Override
public Map<String, List<FileItem>> getFiles() {
return Collections.emptyMap();
}
@Override
public FileItem getFileItem(String string) {
return null;
}
@Override
public FileUploadException getFileUploadException() {
return null;
}
@Override
public boolean hasFileUploadException() {
return false;
}
// ----------------------------------------------------------------------
// Since this is not a multipart request, the parameter methods can be
// delegated.
@ -64,7 +45,7 @@ class SimpleHttpServletRequestWrapper extends FileUploadServletRequest {
}
@Override
public Map<?, ?> getParameterMap() {
public Map<String, String[]> getParameterMap() {
return getDelegate().getParameterMap();
}

38
webapp/src/edu/cornell/mannlib/vitro/webapp/filestorage/uploadrequest/StreamingMultipartHttpServletRequest.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.filestorage.uploadrequest;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
/**
* Wrapping ServletRequest that does multipart. In order to allow
* streaming, this class does NOT save the parts to a temporary directory.
*
*
*/
public class StreamingMultipartHttpServletRequest extends
FileUploadServletRequest {
/**
* Parse the multipart request. Store the info about the request parameters.
* Don't store the uploaded files to a temporary directory to allow streaming.
*
* Only use this if you plan to consume the FileItems using streaming
* to deal with inputs of very large sizes.
*
*/
public StreamingMultipartHttpServletRequest(HttpServletRequest request) {
super(request);
//use a file uploader that does not save the files to a temporary directory.
stashParametersInRequest( request , new ServletFileUpload());
}
@Override
public boolean isMultipart() {
return true;
}
}

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

@ -3,31 +3,35 @@
package edu.cornell.mannlib.vitro.webapp.search;
public class VitroSearchTermNames {
/** Id of entity, vclass or tab */
public static String URI = "URI";
/** search document id */
public static String DOCID = "DocId";
/** java class of the object that the Doc represents. */
public static String JCLASS = "JCLASS";
/** rdf:type */
public static String RDFTYPE = "type";
/** rdf:type */
public static String CLASSGROUP_URI = "classgroup";
/** Modtime from db */
public static String MODTIME = "modTime";
/** class names in human readable form of an individual*/
public static final String CLASSLOCALNAME = "classLocalName";
/** classgroups from the individual's rdf:types */
public static String CLASSGROUP_URI = "classgroup";
/** Most specific types for individual*/
public static String MOST_SPECIFIC_TYPE_URIS = "mostSpecificTypeURIs";
/** time of index in msec since epoc */
public static String INDEXEDTIME= "indexedTime";
/** text for 'full text' search, this is stemmed */
public static String ALLTEXT = "ALLTEXT";
/** text for 'full text' search, this is unstemmed for
* use with wildcards and prefix queries */
public static String ALLTEXTUNSTEMMED = "ALLTEXTUNSTEMMED";
public static String ALLTEXTUNSTEMMED = "ALLTEXTUNSTEMMED";
/** Does the individual have a thumbnail image? 1=yes 0=no */
public static final String THUMBNAIL = "THUMBNAIL";
/** class names in human readable form of an individual*/
public static final String CLASSLOCALNAME = "classLocalName";
/** download url location for thumbnail */
public static final String THUMBNAIL_URL = "THUMBNAIL_URL";
// Fields derived from rdfs:label
/** Raw rdfs:label: no lowercasing, no tokenizing, no stop words, no stemming **/
public static String NAME_RAW = "nameRaw"; //
@ -44,6 +48,11 @@ public class VitroSearchTermNames {
/** rdfs:label lowercased, tokenized, stop words, stemmed **/
public static String NAME_STEMMED = "nameStemmed";
/** preferred title */
public static final String PREFERRED_TITLE = "PREFERRED_TITLE";
public static final String NAME_PHONETIC = "NAME_PHONETIC";
/** rdfs:label lowercased, untokenized, edge-n-gram-filtered for autocomplete on people names **/
public static String AC_NAME_UNTOKENIZED = "acNameUntokenized";
@ -55,24 +64,13 @@ public class VitroSearchTermNames {
/* There is currently no use case for an autocomplete search field that is tokenized but not stemmed.
public static String AC_NAME_UNSTEMMED = "acNameUnstemmed"; */
/** field for beta values of all documents **/
/** Beta values used in weighting **/
public static final String BETA = "BETA";
public static final String PHI = "PHI";
public static final String ADJACENT_NODES = "ADJACENT_NODES";
/** adding phonetic field **/
public static final String ALLTEXT_PHONETIC = "ALLTEXT_PHONETIC";
public static final String NAME_PHONETIC = "NAME_PHONETIC";
/** download url location for thumbnail */
public static final String THUMBNAIL_URL = "THUMBNAIL_URL";
/** source institution url */
/** Source institution URL */
public static final String SITE_URL = "siteURL";
/** source institution name */
/** Source institution name */
public static final String SITE_NAME = "siteName";
/** preferred title */
public static final String PREFERRED_TITLE = "PREFERRED_TITLE";
}

139
webapp/src/edu/cornell/mannlib/vitro/webapp/search/controller/AutocompleteController.java
View file

@ -33,7 +33,7 @@ import edu.cornell.mannlib.vitro.webapp.search.solr.SolrSetup;
/**
* AutocompleteController generates autocomplete content
* via the search index.
* via the search index.
*/
public class AutocompleteController extends VitroAjaxController {
@ -49,7 +49,7 @@ public class AutocompleteController extends VitroAjaxController {
String NORESULT_MSG = "";
private static final int DEFAULT_MAX_HIT_COUNT = 1000;
private static final int DEFAULT_MAX_HIT_COUNT = 1000;
public static final int MAX_QUERY_LENGTH = 500;
@ -57,50 +57,50 @@ public class AutocompleteController extends VitroAjaxController {
protected Actions requiredActions(VitroRequest vreq) {
return SimplePermission.USE_BASIC_AJAX_CONTROLLERS.ACTIONS;
}
@Override
protected void doRequest(VitroRequest vreq, HttpServletResponse response)
throws IOException, ServletException {
try {
String qtxt = vreq.getParameter(PARAM_QUERY);
SolrQuery query = getQuery(qtxt, vreq);
SolrQuery query = getQuery(qtxt, vreq);
if (query == null ) {
log.debug("query for '" + qtxt +"' is null.");
doNoQuery(response);
return;
}
log.debug("query for '" + qtxt +"' is " + query.toString());
SolrServer solr = SolrSetup.getSolrServer(getServletContext());
QueryResponse queryResponse = solr.query(query);
if ( queryResponse == null) {
log.error("Query response for a search was null");
log.error("Query response for a search was null");
doNoSearchResults(response);
return;
}
SolrDocumentList docs = queryResponse.getResults();
if ( docs == null) {
log.error("Docs for a search was null");
log.error("Docs for a search was null");
doNoSearchResults(response);
return;
}
long hitCount = docs.getNumFound();
log.debug("Total number of hits = " + hitCount);
if ( hitCount < 1 ) {
if ( hitCount < 1 ) {
doNoSearchResults(response);
return;
}
}
List<SearchResult> results = new ArrayList<SearchResult>();
for (SolrDocument doc : docs) {
try {
try {
String uri = doc.get(VitroSearchTermNames.URI).toString();
// RY 7/1/2011
// Comment was: VitroSearchTermNames.NAME_RAW is a multivalued field, so doc.get() returns a list.
@ -116,61 +116,71 @@ public class AutocompleteController extends VitroAjaxController {
} else {
name = (String) nameRaw;
}
SearchResult result = new SearchResult(name, uri);
Object mostSpecificType = doc.get(VitroSearchTermNames.MOST_SPECIFIC_TYPE_URIS);
String mst = null;
if (mostSpecificType instanceof List<?>) {
@SuppressWarnings("unchecked")
List<String> mstList = (List<String>) mostSpecificType;
mst = mstList.get(0);
} else {
mst = (String) mostSpecificType;
}
SearchResult result = new SearchResult(name, uri, mst);
results.add(result);
log.debug("results = " + results.toString());
} catch(Exception e){
log.error("problem getting usable individuals from search " +
"hits" + e.getMessage());
}
}
}
Collections.sort(results);
JSONArray jsonArray = new JSONArray();
for (SearchResult result : results) {
jsonArray.put(result.toMap());
}
response.getWriter().write(jsonArray.toString());
} catch (Throwable e) {
log.error(e, e);
log.error(e, e);
doSearchError(response);
}
}
private SolrQuery getQuery(String queryStr, VitroRequest vreq) {
if ( queryStr == null) {
log.error("There was no parameter '"+ PARAM_QUERY
+"' in the request.");
log.error("There was no parameter '"+ PARAM_QUERY
+"' in the request.");
return null;
} else if( queryStr.length() > MAX_QUERY_LENGTH ) {
log.debug("The search was too long. The maximum " +
"query length is " + MAX_QUERY_LENGTH );
return null;
}
SolrQuery query = new SolrQuery();
query.setStart(0)
.setRows(DEFAULT_MAX_HIT_COUNT);
.setRows(DEFAULT_MAX_HIT_COUNT);
setNameQuery(query, queryStr, vreq);
// Filter by type
String typeParam = (String) vreq.getParameter(PARAM_RDFTYPE);
String multipleTypesParam = (String) vreq.getParameter(PARAM_MULTIPLE_RDFTYPE);
if (typeParam != null) {
addFilterQuery(query, typeParam, multipleTypesParam);
}
query.setFields(VitroSearchTermNames.NAME_RAW, VitroSearchTermNames.URI); // fields to retrieve
}
query.setFields(VitroSearchTermNames.NAME_RAW, VitroSearchTermNames.URI, VitroSearchTermNames.MOST_SPECIFIC_TYPE_URIS); // fields to retrieve
// Can't sort on multivalued field, so we sort the results in Java when we get them.
// query.setSortField(VitroSearchTermNames.NAME_LOWERCASE, SolrQuery.ORDER.asc);
return query;
}
private void addFilterQuery(SolrQuery query, String typeParam, String multipleTypesParam) {
if(multipleTypesParam == null || multipleTypesParam.equals("null") || multipleTypesParam.isEmpty()) {
//Single type parameter, process as usual
@ -181,15 +191,13 @@ public class AutocompleteController extends VitroAjaxController {
int len = typeParams.length;
int i;
List<String> filterQueries = new ArrayList<String>();
for(i = 0; i < len; i++) {
filterQueries.add(VitroSearchTermNames.RDFTYPE + ":\"" + typeParams[i] + "\" ");
}
String filterQuery = StringUtils.join(filterQueries, " OR ");
query.addFilterQuery(filterQuery);
}
}
private void setNameQuery(SolrQuery query, String queryStr, HttpServletRequest request) {
@ -197,10 +205,9 @@ public class AutocompleteController extends VitroAjaxController {
if (StringUtils.isBlank(queryStr)) {
log.error("No query string");
}
String tokenizeParam = (String) request.getParameter("tokenize");
String tokenizeParam = (String) request.getParameter("tokenize");
boolean tokenize = "true".equals(tokenizeParam);
// Note: Stemming is only relevant if we are tokenizing: an untokenized name
// query will not be stemmed. So we don't look at the stem parameter until we get to
// setTokenizedNameQuery().
@ -210,43 +217,43 @@ public class AutocompleteController extends VitroAjaxController {
setUntokenizedNameQuery(query, queryStr);
}
}
private void setTokenizedNameQuery(SolrQuery query, String queryStr, HttpServletRequest request) {
/* We currently have no use case for a tokenized, unstemmed autocomplete search field, so the option
* has been disabled. If needed in the future, will need to add a new field and field type which
* is like AC_NAME_STEMMED but doesn't include the stemmer.
String stemParam = (String) request.getParameter("stem");
String stemParam = (String) request.getParameter("stem");
boolean stem = "true".equals(stemParam);
if (stem) {
String acTermName = VitroSearchTermNames.AC_NAME_STEMMED;
String nonAcTermName = VitroSearchTermNames.NAME_STEMMED;
} else {
String acTermName = VitroSearchTermNames.AC_NAME_UNSTEMMED;
String nonAcTermName = VitroSearchTermNames.NAME_UNSTEMMED;
String nonAcTermName = VitroSearchTermNames.NAME_UNSTEMMED;
}
*/
String acTermName = VitroSearchTermNames.AC_NAME_STEMMED;
String nonAcTermName = VitroSearchTermNames.NAME_STEMMED;
String acQueryStr;
if (queryStr.endsWith(" ")) {
acQueryStr = makeTermQuery(nonAcTermName, queryStr, true);
acQueryStr = makeTermQuery(nonAcTermName, queryStr, true);
} else {
int indexOfLastWord = queryStr.lastIndexOf(" ") + 1;
List<String> terms = new ArrayList<String>(2);
String allButLastWord = queryStr.substring(0, indexOfLastWord);
if (StringUtils.isNotBlank(allButLastWord)) {
terms.add(makeTermQuery(nonAcTermName, allButLastWord, true));
}
String lastWord = queryStr.substring(indexOfLastWord);
if (StringUtils.isNotBlank(lastWord)) {
terms.add(makeTermQuery(acTermName, lastWord, false));
}
acQueryStr = StringUtils.join(terms, " AND ");
}
@ -255,26 +262,26 @@ public class AutocompleteController extends VitroAjaxController {
}
private void setUntokenizedNameQuery(SolrQuery query, String queryStr) {
queryStr = queryStr.trim();
private void setUntokenizedNameQuery(SolrQuery query, String queryStr) {
queryStr = queryStr.trim();
queryStr = makeTermQuery(VitroSearchTermNames.AC_NAME_UNTOKENIZED, queryStr, true);
query.setQuery(queryStr);
}
private String makeTermQuery(String term, String queryStr, boolean mayContainWhitespace) {
if (mayContainWhitespace) {
queryStr = "\"" + escapeWhitespaceInQueryString(queryStr) + "\"";
}
return term + ":" + queryStr;
}
private String escapeWhitespaceInQueryString(String queryStr) {
// Solr wants whitespace to be escaped with a backslash
return queryStr.replaceAll("\\s+", "\\\\ ");
}
private void doNoQuery(HttpServletResponse response) throws IOException {
// For now, we are not sending an error message back to the client because
// For now, we are not sending an error message back to the client because
// with the default autocomplete configuration it chokes.
doNoSearchResults(response);
}
@ -288,36 +295,46 @@ public class AutocompleteController extends VitroAjaxController {
private void doNoSearchResults(HttpServletResponse response) throws IOException {
response.getWriter().write("[]");
}
public class SearchResult implements Comparable<Object> {
private String label;
private String uri;
SearchResult(String label, String uri) {
private String msType;
SearchResult(String label, String uri, String msType) {
this.label = label;
this.uri = uri;
this.msType = msType;
}
public String getLabel() {
return label;
}
public String getJsonLabel() {
return JSONObject.quote(label);
}
public String getUri() {
return uri;
}
public String getJsonUri() {
return JSONObject.quote(uri);
}
public String getMsType() {
return msType;
}
public String getJsonMsType() {
return JSONObject.quote(msType);
}
Map<String, String> toMap() {
Map<String, String> map = new HashMap<String, String>();
map.put("label", label);
map.put("uri", uri);
map.put("msType", msType);
return map;
}

3
webapp/src/edu/cornell/mannlib/vitro/webapp/search/controller/SearchServiceController.java
View file

@ -25,6 +25,7 @@ import edu.cornell.mannlib.vitro.webapp.controller.freemarker.FreemarkerHttpServ
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.ExceptionResponseValues;
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.filestorage.uploadrequest.FileUploadServletRequest;
import edu.cornell.mannlib.vitro.webapp.filestorage.uploadrequest.MultipartHttpServletRequest;
import edu.cornell.mannlib.vitro.webapp.search.indexing.IndexBuilder;
@ -45,7 +46,7 @@ public class SearchServiceController extends FreemarkerHttpServlet {
protected Actions requiredActions(VitroRequest vreq) {
try{
// Works by side effect: parse the multi-part request and stash FileItems in request
new MultipartHttpServletRequest( vreq );
FileUploadServletRequest.parseRequest(vreq, 0);
//first figure out if the password and email login to an account with a password
String pw = vreq.getParameter("password");

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

@ -69,6 +69,7 @@ public class IndividualToSolrDocument {
//add classes, classgroups get if prohibited because of its class
StringBuffer classPublicNames = new StringBuffer("");
addClasses(ind, doc, classPublicNames);
addMostSpecificTypeUris( ind, doc );
log.debug(ind.getURI() + " post class boost: " + doc.getDocumentBoost());
@ -202,7 +203,6 @@ public class IndividualToSolrDocument {
doc.addField(term.ALLTEXT, alltext);
doc.addField(term.ALLTEXTUNSTEMMED, alltext);
doc.addField(term.ALLTEXT_PHONETIC, alltext);
}
@ -256,7 +256,7 @@ public class IndividualToSolrDocument {
if( vclasses == null || vclasses.isEmpty() ){
throw new SkipIndividualException("Not indexing because individual has no classes");
}
for(VClass clz : vclasses){
if(clz.getURI() == null){
continue;
@ -286,6 +286,16 @@ public class IndividualToSolrDocument {
}
}
}
protected void addMostSpecificTypeUris(Individual ind, SolrInputDocument doc){
List<String> mstURIs = ind.getMostSpecificTypeURIs();
if( mstURIs != null ){
for( String typeURI : mstURIs ){
if( typeURI != null && ! typeURI.trim().isEmpty() )
doc.addField(term.MOST_SPECIFIC_TYPE_URIS, typeURI);
}
}
}
protected void addLabel(Individual ind, SolrInputDocument doc) {
String value = "";

15
webapp/src/edu/cornell/mannlib/vitro/webapp/services/freemarker/FreemarkerProcessingServiceImpl.java
View file

@ -13,10 +13,8 @@ import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
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.utils.log.LogUtils;
import freemarker.core.Environment;
import freemarker.core.ParseException;
import freemarker.template.Configuration;
import freemarker.template.Template;
@ -75,18 +73,7 @@ public class FreemarkerProcessingServiceImpl implements
StringWriter writer = new StringWriter();
try {
// Add directives to the map. For some reason, having them in the
// configuration is not enough.
map.putAll(FreemarkerConfiguration.getDirectives());
// Add request and servlet context as custom attributes of the
// environment, so they
// can be used in directives.
Environment env = template.createProcessingEnvironment(map, writer);
env.setCustomAttribute("request", req);
env.setCustomAttribute("context", req.getSession()
.getServletContext());
env.process();
template.process(map, writer);
return writer.toString();
} catch (TemplateException e) {
throw new TemplateProcessingException(

104
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/UpdateKnowledgeBase.java
View file

@ -5,7 +5,11 @@ package edu.cornell.mannlib.vitro.webapp.servlet.setup;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.StringWriter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
@ -31,11 +35,13 @@ import com.hp.hpl.jena.shared.Lock;
import com.hp.hpl.jena.vocabulary.RDF;
import com.hp.hpl.jena.vocabulary.RDFS;
import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties;
import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.ontology.update.KnowledgeBaseUpdater;
import edu.cornell.mannlib.vitro.webapp.ontology.update.UpdateSettings;
import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus;
/**
* Invokes process to test whether the knowledge base needs any updating
@ -44,21 +50,10 @@ import edu.cornell.mannlib.vitro.webapp.ontology.update.UpdateSettings;
*
*/
public class UpdateKnowledgeBase implements ServletContextListener {
public static final String KBM_REQURIED_AT_STARTUP = "KNOWLEDGE_BASE_MIGRATION_REQUIRED_AT_STARTUP";
private final static Log log = LogFactory.getLog(UpdateKnowledgeBase.class);
private static final String DATA_DIR = "/WEB-INF/ontologies/update/";
private static final String LOG_DIR = "logs/";
private static final String CHANGED_DATA_DIR = "changedData/";
private static final String ASK_QUERY_FILE = DATA_DIR + "askUpdated.sparql";
private static final String SUCCESS_ASSERTIONS_FILE = DATA_DIR + "success.n3";
private static final String SUCCESS_RDF_FORMAT = "N3";
private static final String DIFF_FILE = DATA_DIR + "diff.tab.txt";
private static final String REMOVED_DATA_FILE = DATA_DIR + CHANGED_DATA_DIR + "removedData.n3";
private static final String ADDED_DATA_FILE = DATA_DIR + CHANGED_DATA_DIR + "addedData.n3";
private static final String SPARQL_CONSTRUCT_ADDITIONS_DIR = DATA_DIR + "sparqlConstructs/additions/";
private static final String SPARQL_CONSTRUCT_DELETIONS_DIR = DATA_DIR + "sparqlConstructs/deletions/";
private static final String OLD_TBOX_MODEL_DIR = DATA_DIR + "oldVersion/";
private static final String NEW_TBOX_MODEL_DIR = "/WEB-INF/filegraph/tbox/";
private static final String OLD_TBOX_ANNOTATIONS_DIR = DATA_DIR + "oldAnnotations/";
@ -72,33 +67,15 @@ public class UpdateKnowledgeBase implements ServletContextListener {
private static final String LOADED_STARTUPT_DISPLAYMODEL_DIR = "/WEB-INF/ontologies/app/loadedAtStartup/";
private static final String OLD_DISPLAYMODEL_VIVOLISTVIEW_PATH = DATA_DIR + "oldDisplayModel/vivoListViewConfig.rdf";
@Override
public void contextInitialized(ServletContextEvent sce) {
try {
ServletContext ctx = sce.getServletContext();
// If the DATA_DIR directory doesn't exist no migration check will be done.
// This is a normal situation for Vitro.
File updateDirectory = new File(ctx.getRealPath(DATA_DIR));
if (!updateDirectory.exists()) {
log.debug("Directory " + ctx.getRealPath(DATA_DIR) + " does not exist, no migration check will be attempted.");
return;
}
ServletContext ctx = sce.getServletContext();
StartupStatus ss = StartupStatus.getBean(ctx);
String logFileName = DATA_DIR + LOG_DIR + timestampedFileName("knowledgeBaseUpdate", "log");
String errorLogFileName = DATA_DIR + LOG_DIR + timestampedFileName("knowledgeBaseUpdate.error", "log");
try {
UpdateSettings settings = new UpdateSettings();
settings.setAskUpdatedQueryFile(getAskUpdatedQueryPath(ctx));
settings.setDataDir(ctx.getRealPath(DATA_DIR));
settings.setSparqlConstructAdditionsDir(ctx.getRealPath(SPARQL_CONSTRUCT_ADDITIONS_DIR));
settings.setSparqlConstructDeletionsDir(ctx.getRealPath(SPARQL_CONSTRUCT_DELETIONS_DIR));
settings.setDiffFile(ctx.getRealPath(DIFF_FILE));
settings.setSuccessAssertionsFile(ctx.getRealPath(SUCCESS_ASSERTIONS_FILE));
settings.setSuccessRDFFormat(SUCCESS_RDF_FORMAT);
settings.setLogFile(ctx.getRealPath(logFileName));
settings.setErrorLogFile(ctx.getRealPath(errorLogFileName));
settings.setAddedDataFile(ctx.getRealPath(ADDED_DATA_FILE));
settings.setRemovedDataFile(ctx.getRealPath(REMOVED_DATA_FILE));
putReportingPathsIntoSettings(ctx, settings);
WebappDaoFactory wadf = ModelAccess.on(ctx).getWebappDaoFactory();
settings.setDefaultNamespace(wadf.getDefaultNamespace());
settings.setAssertionOntModelSelector(ModelAccess.on(ctx).getBaseOntModelSelector());
@ -157,21 +134,54 @@ public class UpdateKnowledgeBase implements ServletContextListener {
}
}
} catch (Exception ioe) {
String errMsg = "Exception updating knowledge base " +
"for ontology changes: ";
// Tomcat doesn't always seem to print exceptions thrown from
// context listeners
System.out.println(errMsg);
ioe.printStackTrace();
throw new RuntimeException(errMsg, ioe);
ss.fatal(this, "Exception updating knowledge base for ontology changes: ", ioe);
}
} catch (Throwable t){
log.warn("warning", t);
ss.fatal(this, "Exception updating knowledge base for ontology changes: ", t);
}
} catch (Throwable t) {
t.printStackTrace();
ss.fatal(this, "Exception updating knowledge base for ontology changes: ", t);
}
}
/**
* Create the directories where we will report on the update.
* Put the paths for the directories and files into the settings object.
*/
private void putReportingPathsIntoSettings(ServletContext ctx, UpdateSettings settings) throws IOException {
ConfigurationProperties props = ConfigurationProperties.getBean(ctx);
Path homeDir = Paths.get(props.getProperty("vitro.home"));
Path dataDir = createDirectory(homeDir, "upgrade", "knowledgeBase");
settings.setDataDir(dataDir.toString());
StartupStatus.getBean(ctx).info(this, "Updating knowledge base: reports are in '" + dataDir + "'");
settings.setAskUpdatedQueryFile(dataDir.resolve("askUpdated.sparql").toString());
settings.setDiffFile(dataDir.resolve("diff.tab.txt").toString());
settings.setSuccessAssertionsFile(dataDir.resolve("success.n3").toString());
settings.setSuccessRDFFormat("N3");
settings.setSparqlConstructAdditionsDir(createDirectory(dataDir, "sparqlConstructs", "additions").toString());
settings.setSparqlConstructDeletionsDir(createDirectory(dataDir, "sparqlConstructs", "deletions").toString());
Path changedDir = createDirectory(dataDir, "changedData");
settings.setAddedDataFile(changedDir.resolve("addedData.n3").toString());
settings.setRemovedDataFile(changedDir.resolve("removedData.n3").toString());
Path logDir = createDirectory(dataDir, "logs");
settings.setLogFile(logDir.resolve(timestampedFileName("knowledgeBaseUpdate", "log")).toString());
settings.setErrorLogFile(logDir.resolve(timestampedFileName("knowledgeBaseUpdate.error", "log")).toString());
}
private Path createDirectory(Path parent, String... children) throws IOException {
Path dir = parent;
for (String child : children) {
dir = dir.resolve(child);
}
Files.createDirectories(dir);
return dir;
}
//Multiple changes from 1.4 to 1.5 will occur
//update migration model
@ -473,15 +483,11 @@ public class UpdateKnowledgeBase implements ServletContextListener {
}
}
@Override
public void contextDestroyed(ServletContextEvent arg0) {
// nothing to do
}
public static String getAskUpdatedQueryPath(ServletContext ctx) {
return ctx.getRealPath(ASK_QUERY_FILE);
}
private static String timestampedFileName(String prefix, String suffix) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH-mm-sss");
return prefix + "." + sdf.format(new Date()) + "." + suffix;

2
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/UpdatePermissionSetUris.java
View file

@ -190,7 +190,7 @@ public class UpdatePermissionSetUris implements ServletContextListener {
File homeDirectory = new File(homeDirectoryPath);
confirmIsDirectory(homeDirectory);
File upgradeDirectory = createDirectory(homeDirectory, "upgrade");
File upgradeDirectory = createDirectory(homeDirectory, "upgrade/permissions");
String filename = timestampedFilename("UpgradePermissionSetUris",
".txt");
this.file = new File(upgradeDirectory, filename);

234
webapp/src/edu/cornell/mannlib/vitro/webapp/utils/pageDataGetter/BrowseDataGetter.java
View file

@ -1,234 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.utils.pageDataGetter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONArray;
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.beans.VClassGroup;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.UrlBuilder;
import edu.cornell.mannlib.vitro.webapp.controller.json.JsonServlet;
import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.VClassGroupsForRequest;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VClassGroupCache;
import edu.cornell.mannlib.vitro.webapp.utils.JsonToFmModel;
import edu.cornell.mannlib.vitro.webapp.web.templatemodels.VClassGroupTemplateModel;
import edu.cornell.mannlib.vitro.webapp.web.templatemodels.VClassTemplateModel;
import edu.cornell.mannlib.vitro.webapp.web.templatemodels.individuallist.ListedIndividual;
public class BrowseDataGetter implements PageDataGetter {
final static Log log = LogFactory.getLog(BrowseDataGetter.class);
@Override
public Map<String, Object> getData(ServletContext context,
VitroRequest vreq, String pageUri, Map<String, Object> page) {
try{
Map params = vreq.getParameterMap();
Mode mode = getMode( vreq, params );
switch( mode ){
case VCLASS_ALPHA:
return doClassAlphaDisplay(params,vreq,context);
case CLASS_GROUP:
return doClassGroupDisplay(params, vreq, context);
case VCLASS:
return doClassDisplay(params, vreq, context);
case ALL_CLASS_GROUPS:
return doAllClassGroupsDisplay( params, page, vreq, context);
default:
return doAllClassGroupsDisplay( params, page, vreq, context);
}
}catch(Throwable th){
log.error(th,th);
return Collections.emptyMap();
}
}
@Override
public String getType() {
return DisplayVocabulary.HOME_PAGE_TYPE;
}
//Get data servuice
@Override
public String getDataServiceUrl() {
return UrlBuilder.getUrl("/dataservice?getSolrIndividualsByVClass=1&vclassId=");
}
private Map<String, Object> doClassAlphaDisplay( Map params, VitroRequest request, ServletContext context) throws Exception {
Map<String,Object> body = new HashMap<String,Object>();
body.putAll(getCommonValues(context, request));
body.putAll(getClassAlphaValues(params,request,context));
return body;
}
private Map<String,Object> getClassAlphaValues( Map params, VitroRequest request, ServletContext context) throws Exception{
Map<String,Object> map= new HashMap<String,Object>();
String classUri = getParam(Mode.VCLASS, request, params);
VitroRequest vreq = new VitroRequest(request);
VClass vclass = vreq.getWebappDaoFactory().getVClassDao().getVClassByURI(classUri);
map.put("class", new VClassTemplateModel(vclass));
JSONObject vclassRes = JsonServlet.getSolrIndividualsByVClass(vclass.getURI(), request, context);
map.put("totalCount", JsonToFmModel.convertJSONObjectToMap( (String) vclassRes.get("totalCount") ));
map.put("alpha", JsonToFmModel.convertJSONObjectToMap( (String) vclassRes.get("alpha") ));
map.put("individuals", JsonToFmModel.convertJSONArrayToList( (JSONArray) vclassRes.get("individuals") ));
map.put("pages", JsonToFmModel.convertJSONArrayToList( (JSONArray) vclassRes.get("pages") ));
map.put("letters", JsonToFmModel.convertJSONArrayToList( (JSONArray) vclassRes.get("letters") ));
return map;
}
private Map<String,Object> getCommonValues( ServletContext context, VitroRequest vreq){
Map<String,Object> values = new HashMap<String,Object>();
VClassGroupsForRequest vcgc = VClassGroupCache.getVClassGroups(vreq);
List<VClassGroup> cgList = vcgc.getGroups();
LinkedList<VClassGroupTemplateModel> cgtmList = new LinkedList<VClassGroupTemplateModel>();
for( VClassGroup classGroup : cgList){
cgtmList.add( new VClassGroupTemplateModel( classGroup ));
}
values.put("vClassGroups",cgtmList);
return values;
}
protected Map<String, Object> doAllClassGroupsDisplay( Map params, Map<String, Object> page, VitroRequest request, ServletContext context) {
Map<String,Object> body = new HashMap<String,Object>();
body.putAll(getCommonValues(context,request));
body.putAll(getAllClassGroupData(request, params, page, context));
return body;
}
/**
* Gets a list of all VClassGroups with vclasses with individual counts.
* @param params2
*/
protected Map<String,Object> getAllClassGroupData(VitroRequest request, Map params, Map<String, Object> page, ServletContext context){
Map<String,Object> map = new HashMap<String,Object>();
return map;
}
protected Map<String, Object> doClassDisplay( Map params,
VitroRequest request, ServletContext context) {
Map<String,Object> body = new HashMap<String,Object>();
body.putAll(getCommonValues(context,request));
body.putAll(getClassData(request,params,context));
return body;
}
private Map<String, Object> getClassData(VitroRequest request, Map params, ServletContext context) {
Map<String,Object> map = new HashMap<String,Object>();
map.putAll(getClassGroupData(request, params,context));
String classUri = getParam(Mode.VCLASS, request, params);
VitroRequest vreq = new VitroRequest(request);
VClass vclass = vreq.getWebappDaoFactory().getVClassDao().getVClassByURI(classUri);
map.put("class", new VClassTemplateModel(vclass));
List<Individual> inds = vreq.getWebappDaoFactory().getIndividualDao()
.getIndividualsByVClass(vclass);
List<ListedIndividual> tInds = new ArrayList<ListedIndividual>(inds.size());
for( Individual ind : inds){
tInds.add(new ListedIndividual(ind, vreq));
}
map.put("individualsInClass", tInds);
return map;
}
protected Map<String, Object> doClassGroupDisplay(Map params, VitroRequest request, ServletContext context) {
Map<String,Object> body = new HashMap<String,Object>();
body.putAll(getCommonValues(context,request));
body.putAll( getClassGroupData(request,params, context));
return body;
}
protected Map<String, Object> getClassGroupData(VitroRequest request, Map params, ServletContext context) {
Map<String,Object> map = new HashMap<String,Object>();
String vcgUri = getParam(Mode.CLASS_GROUP, request, params);
VitroRequest vreq = new VitroRequest(request);
VClassGroupsForRequest vcgc = VClassGroupCache.getVClassGroups(request);
VClassGroup vcg = vcgc.getGroup(vcgUri);
ArrayList<VClassTemplateModel> classes = new ArrayList<VClassTemplateModel>(vcg.size());
for( VClass vc : vcg){
classes.add(new VClassTemplateModel(vc));
}
map.put("classes", classes);
map.put("classGroup", new VClassGroupTemplateModel(vcg));
return map;
}
enum Mode{
VCLASS_ALPHA("vclassAlpha"),
VCLASS("vclassUri"),
CLASS_GROUP("classgroupUri"),
ALL_CLASS_GROUPS("all");
String param;
Mode(String param){
this.param = param;
}
}
protected final static Mode DEFAULT_MODE = Mode.ALL_CLASS_GROUPS;
protected Mode getMode(VitroRequest request, Map<String, Object> params){
for( Mode mode : Mode.values()){
String queryParam = request.getParameter( mode.param );
if( queryParam != null && !queryParam.isEmpty() ){
return mode;
}
Object obj = params.get( mode.param );
String param = obj != null ? obj.toString():null;
if( param != null && !param.isEmpty() ){
return mode;
}
}
return DEFAULT_MODE;
}
public static String getParam(Mode mode, VitroRequest request, Map params){
if( request.getParameter(mode.param) != null )
return request.getParameter(mode.param);
if( params.get(mode.param) != null )
return params.get(mode.param).toString();
else
return null;
}
/**
* For processig of JSONObject
*/
public JSONObject convertToJSON(Map<String, Object> dataMap, VitroRequest vreq) {
JSONObject rObj = null;
return rObj;
}
}

155
webapp/src/edu/cornell/mannlib/vitro/webapp/utils/pageDataGetter/ClassGroupPageData.java
View file

@ -1,155 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.utils.pageDataGetter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletContext;
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.controller.freemarker.UrlBuilder;
import edu.cornell.mannlib.vitro.webapp.dao.VClassGroupsForRequest;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VClassGroupCache;
import edu.cornell.mannlib.vitro.webapp.web.templatemodels.VClassGroupTemplateModel;
/**
* This will pass these variables to the template:
* classGroupUri: uri of the classgroup associated with this page.
* vClassGroup: a data structure that is the classgroup associated with this page.
*/
public class ClassGroupPageData implements PageDataGetter{
private static final Log log = LogFactory.getLog(ClassGroupPageData.class);
@Override
public Map<String,Object> getData(ServletContext context, VitroRequest vreq, String pageUri, Map<String, Object> page ){
HashMap<String, Object> data = new HashMap<String,Object>();
String classGroupUri = vreq.getWebappDaoFactory().getPageDao().getClassGroupPage(pageUri);
data.put("classGroupUri", classGroupUri);
VClassGroupsForRequest vcgc = VClassGroupCache.getVClassGroups(vreq);
List<VClassGroup> vcgList = vcgc.getGroups();
VClassGroup group = null;
for( VClassGroup vcg : vcgList){
if( vcg.getURI() != null && vcg.getURI().equals(classGroupUri)){
group = vcg;
break;
}
}
if( classGroupUri != null && !classGroupUri.isEmpty() && group == null ){
/*This could be for two reasons: one is that the classgroup doesn't exist
* The other is that there are no individuals in any of the classgroup's classes */
group = vreq.getWebappDaoFactory().getVClassGroupDao().getGroupByURI(classGroupUri);
if( group != null ){
List<VClassGroup> vcgFullList = vreq.getWebappDaoFactory().getVClassGroupDao()
.getPublicGroupsWithVClasses(false, true, false);
for( VClassGroup vcg : vcgFullList ){
if( classGroupUri.equals(vcg.getURI()) ){
group = vcg;
break;
}
}
if( group == null ){
log.error("Cannot get classgroup '" + classGroupUri + "' for page '" + pageUri + "'");
}else{
setAllClassCountsToZero(group);
}
}else{
log.error("classgroup " + classGroupUri + " does not exist in the system");
}
}
log.debug("Retrieved class group " + group.getURI() + " and returning to template");
//if debug enabled, print out the number of entities within each class in the class gorup
if(log.isDebugEnabled()){
List<VClass> groupClasses = group.getVitroClassList();
for(VClass v: groupClasses) {
log.debug("Class " + v.getName() + " - " + v.getURI() + " has " + v.getEntityCount() + " entities");
}
}
data.put("vClassGroup", group); //may put null
//This page level data getters tries to set its own template,
// not all of the data getters need to do this.
data.put("bodyTemplate", "page-classgroup.ftl");
//Also add data service url
//Hardcoding for now, need a more dynamic way of doing this
data.put("dataServiceUrlIndividualsByVClass", this.getDataServiceUrl());
return data;
}
public static VClassGroupTemplateModel getClassGroup(String classGroupUri, ServletContext context, VitroRequest vreq){
VClassGroupsForRequest vcgc = VClassGroupCache.getVClassGroups(vreq);
List<VClassGroup> vcgList = vcgc.getGroups();
VClassGroup group = null;
for( VClassGroup vcg : vcgList){
if( vcg.getURI() != null && vcg.getURI().equals(classGroupUri)){
group = vcg;
break;
}
}
if( classGroupUri != null && !classGroupUri.isEmpty() && group == null ){
/*This could be for two reasons: one is that the classgroup doesn't exist
* The other is that there are no individuals in any of the classgroup's classes */
group = vreq.getWebappDaoFactory().getVClassGroupDao().getGroupByURI(classGroupUri);
if( group != null ){
List<VClassGroup> vcgFullList = vreq.getWebappDaoFactory().getVClassGroupDao()
.getPublicGroupsWithVClasses(false, true, false);
for( VClassGroup vcg : vcgFullList ){
if( classGroupUri.equals(vcg.getURI()) ){
group = vcg;
break;
}
}
if( group == null ){
log.error("Cannot get classgroup '" + classGroupUri + "'");
return null;
}else{
setAllClassCountsToZero(group);
}
}else{
log.error("classgroup " + classGroupUri + " does not exist in the system");
return null;
}
}
return new VClassGroupTemplateModel(group);
}
@Override
public String getType(){
return PageDataGetterUtils.generateDataGetterTypeURI(ClassGroupPageData.class.getName());
}
//Get data servuice
@Override
public String getDataServiceUrl() {
return UrlBuilder.getUrl("/dataservice?getSolrIndividualsByVClass=1&vclassId=");
}
/**
* For processing of JSONObject
*/
//Currently empty, TODO: Review requirements
@Override
public JSONObject convertToJSON(Map<String, Object> dataMap, VitroRequest vreq) {
JSONObject rObj = null;
return rObj;
}
protected static void setAllClassCountsToZero(VClassGroup vcg){
for(VClass vc : vcg){
vc.setEntityCount(0);
}
}
}

316
webapp/src/edu/cornell/mannlib/vitro/webapp/utils/pageDataGetter/IndividualsForClassesDataGetter.java
View file

@ -1,316 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.utils.pageDataGetter;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletContext;
import org.apache.commons.lang.StringUtils;
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.controller.freemarker.UrlBuilder;
import edu.cornell.mannlib.vitro.webapp.dao.PageDao;
import edu.cornell.mannlib.vitro.webapp.dao.VClassGroupsForRequest;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VClassGroupCache;
import edu.cornell.mannlib.vitro.webapp.web.templatemodels.VClassGroupTemplateModel;
/**
* This will pass these variables to the template:
* classGroupUri: uri of the classgroup associated with this page.
* vClassGroup: a data structure that is the classgroup associated with this page.
*/
public class IndividualsForClassesDataGetter implements PageDataGetter{
private static final Log log = LogFactory.getLog(IndividualsForClassesDataGetter.class);
protected static String restrictClassesTemplateName = null;
@Override
public Map<String,Object> getData(ServletContext context, VitroRequest vreq, String pageUri, Map<String, Object> page ){
this.setTemplateName();
HashMap<String, Object> data = new HashMap<String,Object>();
//This is the old technique of getting class intersections
PageDao pageDao = vreq.getWebappDaoFactory().getPageDao();
Map<String, Object> classIntersectionsMap = getClassIntersectionsMap(pageDao, pageUri);
try{
List<String> classes = retrieveClasses(context, classIntersectionsMap);
List<String> restrictClasses = retrieveRestrictClasses(context, classIntersectionsMap);
log.debug("Retrieving classes for " + classes.toString() + " and restricting by " + restrictClasses.toString());
processClassesAndRestrictions(vreq, context, data, classes, restrictClasses);
//Also add data service url
//Hardcoding for now, need a more dynamic way of doing this
data.put("dataServiceUrlIndividualsByVClass", this.getDataServiceUrl());
//this is the class group associated with the data getter utilized for display on menu editing, not the custom one created
data.put("classGroupUri", pageDao.getClassGroupPage(pageUri));
} catch(Exception ex) {
log.error("An error occurred retrieving Vclass Intersection individuals", ex);
}
return data;
}
protected void setTemplateName() {
this.restrictClassesTemplateName = "restricted";
}
protected Map<String, Object> getClassIntersectionsMap(PageDao pageDao,
String pageUri) {
// TODO Auto-generated method stub
return pageDao.getClassesAndRestrictionsForPage(pageUri);
}
protected List<String> retrieveClasses(
ServletContext context, Map<String, Object> classIntersectionsMap) {
List<String> restrictClasses = (List<String>) classIntersectionsMap.get("classes");
return restrictClasses;
}
protected List<String> retrieveRestrictClasses(
ServletContext context, Map<String, Object> classIntersectionsMap) {
List<String> restrictClasses = (List<String>) classIntersectionsMap.get("restrictClasses");
return restrictClasses;
}
protected void processClassesAndRestrictions(VitroRequest vreq, ServletContext context,
HashMap<String, Object> data, List<String> classes, List<String> restrictClasses ) {
processClassesForDisplay(vreq, context, data, classes);
processRestrictionClasses(vreq, context, data, restrictClasses);
processIntersections(vreq, context, data);
}
//At this point, data specifices whether or not intersections included
private void processIntersections(VitroRequest vreq,
ServletContext context, HashMap<String, Object> data) {
VClassGroup classesGroup = (VClassGroup) data.get("vClassGroup");
List<VClass> vclassList = classesGroup.getVitroClassList();
List<VClass> restrictClasses = (List<VClass>) data.get("restrictVClasses");
//if there are restrict classes, then update counts
if(restrictClasses.size() > 0) {
log.debug("Restriction classes exist");
List<VClass> newVClassList = new ArrayList<VClass>();
//Iterate through vclasses and get updated counts, iterated and saved in same order as initially included
for(VClass v: vclassList) {
int oldCount = v.getEntityCount();
//Making a copy so as to ensure we don't touch the values in the cache
VClass copyVClass = makeCopyVClass(v);
int count = retrieveCount(vreq, context, v, restrictClasses);
if(oldCount != count) {
log.debug("Old count was " + v.getEntityCount() + " and New count for " + v.getURI() + " is " + count);
copyVClass.setEntityCount(count);
}
newVClassList.add(copyVClass);
}
classesGroup.setVitroClassList(newVClassList);
//TODO: Do we need to do this again or will this already be reset?
data.put("vClassGroup", classesGroup);
}
}
private VClass makeCopyVClass(VClass v) {
VClass copyVClass = new VClass(v.getURI());
copyVClass.setLocalName(copyVClass.getLocalName());
copyVClass.setDisplayRank(v.getDisplayRank());
copyVClass.setName(v.getName());
copyVClass.setNamespace(v.getNamespace());
copyVClass.setEntityCount(v.getEntityCount());
return copyVClass;
}
//update class count based on restrict classes
private int retrieveCount(VitroRequest vreq, ServletContext context, VClass v, List<VClass> restrictClasses) {
//Execute solr query that returns only count of individuals
log.debug("Entity count is " + v.getEntityCount());
List<String> classUris = new ArrayList<String>();
classUris.add(v.getURI());
for(VClass r: restrictClasses) {
classUris.add(r.getURI());
}
long count = PageDataGetterUtils.getIndividualCountForIntersection(vreq, context, classUris);
return new Long(count).intValue();
}
private void processClassesForDisplay(VitroRequest vreq, ServletContext context, HashMap<String, Object> data, List<String> classes) {
VClassGroup classesGroup = new VClassGroup();
classesGroup.setURI("displayClasses");
log.debug("Processing classes that will be displayed");
List<VClass> vClasses = new ArrayList<VClass>();
VClassGroupsForRequest vcgc = VClassGroupCache.getVClassGroups(vreq);
for(String classUri: classes) {
//Retrieve vclass from cache to get the count
VClass vclass = vcgc.getCachedVClass(classUri);
//if not found in cache, possibly due to not being in any class group
if(vclass == null) {
vclass = vreq.getWebappDaoFactory().getVClassDao().getVClassByURI(classUri);
}
if(vclass != null) {
log.debug("VClass does exist for " + classUri + " and entity count is " + vclass.getEntityCount());
vClasses.add(vclass);
} else {
log.debug("Vclass " + classUri + " does not exist in the cache");
log.error("Error occurred, vclass does not exist for this uri " + classUri);
//Throw exception here
}
}
//Sort these classes
Collections.sort(vClasses);
log.debug("Sorting complete for V Classes");
classesGroup.setVitroClassList(vClasses);
log.debug("Returning vitro class list in data for template");
//Set vclass group
data.put("vClassGroup", classesGroup);
}
private void processRestrictionClasses(VitroRequest vreq, ServletContext context,
HashMap<String, Object> data, List<String> restrictClasses) {
try {
VClassGroup restrictClassesGroup = new VClassGroup();
restrictClassesGroup.setURI("restrictClasses");
List<VClass> restrictVClasses = new ArrayList<VClass>();
List<String> urlEncodedRestrictClasses = new ArrayList<String>();
VClassGroupsForRequest vcgc = VClassGroupCache.getVClassGroups(vreq);
if(restrictClasses.size() > 0) {
//classes for restriction are not displayed so don't need to include their class individual counts
for(String restrictClassUri: restrictClasses) {
//Also uses cache to remain consistent with process classes and also allow
//vclasses to be returned even if switched to display model, although
//uris used within display model editing and not vclass objects
VClass vclass = vcgc.getCachedVClass(restrictClassUri);
//if not found in cache, possibly due to not being in any class group
if(vclass == null) {
vclass = vreq.getWebappDaoFactory().getVClassDao().getVClassByURI(restrictClassUri);
}
if(vclass != null) {
log.debug("Found restrict class and adding to list " + restrictClassUri);
restrictVClasses.add(vclass);
} else {
log.error("Error occurred, vclass does not exist for this uri " + restrictClassUri);
}
//Assuming utf-8?
urlEncodedRestrictClasses.add(URLEncoder.encode(restrictClassUri, "UTF-8"));
}
restrictClassesGroup.setVitroClassList(restrictVClasses);
restrictClassesGroup.setIndividualCount(restrictVClasses.size());
} else {
}
String[] restrictClassesArray = new String[urlEncodedRestrictClasses.size()];
restrictClassesArray = urlEncodedRestrictClasses.toArray(restrictClassesArray);
//In case just want uris
log.debug("Variable name for including restriction classes " + getRestrictClassesTemplateName());
data.put(getRestrictClassesTemplateName(), StringUtils.join(restrictClassesArray, ","));
data.put("restrictVClasses", restrictVClasses);
//not sure if this is useful
data.put("restrictVClassGroup", restrictClassesGroup);
} catch(Exception ex) {
log.error("An error occurred in processing restriction classes ", ex);
}
}
public static VClassGroupTemplateModel getClassGroup(String classGroupUri, ServletContext context, VitroRequest vreq){
VClassGroupsForRequest vcgc = VClassGroupCache.getVClassGroups(vreq);
List<VClassGroup> vcgList = vcgc.getGroups();
VClassGroup group = null;
for( VClassGroup vcg : vcgList){
if( vcg.getURI() != null && vcg.getURI().equals(classGroupUri)){
group = vcg;
break;
}
}
if( classGroupUri != null && !classGroupUri.isEmpty() && group == null ){
/*This could be for two reasons: one is that the classgroup doesn't exist
* The other is that there are no individuals in any of the classgroup's classes */
group = vreq.getWebappDaoFactory().getVClassGroupDao().getGroupByURI(classGroupUri);
if( group != null ){
List<VClassGroup> vcgFullList = vreq.getWebappDaoFactory().getVClassGroupDao()
.getPublicGroupsWithVClasses(false, true, false);
for( VClassGroup vcg : vcgFullList ){
if( classGroupUri.equals(vcg.getURI()) ){
group = vcg;
break;
}
}
if( group == null ){
log.error("Cannot get classgroup '" + classGroupUri + "'");
return null;
}else{
setAllClassCountsToZero(group);
}
}else{
log.error("classgroup " + classGroupUri + " does not exist in the system");
return null;
}
}
return new VClassGroupTemplateModel(group);
}
@Override
public String getType(){
return PageDataGetterUtils.generateDataGetterTypeURI(IndividualsForClassesDataGetter.class.getName());
}
//Get data servuice
@Override
public String getDataServiceUrl() {
return UrlBuilder.getUrl("/dataservice?getSolrIndividualsByVClasses=1&vclassId=");
}
/**
* For processig of JSONObject
*/
@Override
public JSONObject convertToJSON(Map<String, Object> map, VitroRequest vreq) {
JSONObject rObj = PageDataGetterUtils.processVclassResultsJSON(map, vreq, true);
return rObj;
}
protected static void setAllClassCountsToZero(VClassGroup vcg){
for(VClass vc : vcg){
vc.setEntityCount(0);
}
}
protected static String getAlphaParameter(VitroRequest request){
return request.getParameter("alpha");
}
protected static int getPageParameter(VitroRequest request) {
String pageStr = request.getParameter("page");
if( pageStr != null ){
try{
return Integer.parseInt(pageStr);
}catch(NumberFormatException nfe){
log.debug("could not parse page parameter");
return 1;
}
}else{
return 1;
}
}
//Get template parameter
private static String getRestrictClassesTemplateName() {
return restrictClassesTemplateName;
}
}

27
webapp/src/edu/cornell/mannlib/vitro/webapp/utils/pageDataGetter/PageDataGetter.java
View file

@ -1,27 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.utils.pageDataGetter;
import java.util.Map;
import javax.servlet.ServletContext;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.UrlBuilder;
import org.json.JSONObject;
public interface PageDataGetter{
Map<String,Object> getData(ServletContext contect, VitroRequest vreq, String pageUri, Map<String, Object> page );
/** Gets the type that this class applies to */
//This has been changed to return the class name for data getter used in menu management
String getType();
//get data service url based on data getter requirements
//Get data servuice
String getDataServiceUrl();
/**Convert data to JSONObject based on what's required for the data processing**/
JSONObject convertToJSON(Map<String, Object> map, VitroRequest vreq);
}

339
webapp/src/edu/cornell/mannlib/vitro/webapp/utils/pageDataGetter/PageDataGetterUtils.java
View file

@ -1,339 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.utils.pageDataGetter;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
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.JSONObject;
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.Controllers;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.IndividualListController;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.IndividualListController.PageRecord;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.UrlBuilder;
import edu.cornell.mannlib.vitro.webapp.controller.json.JsonServlet;
import edu.cornell.mannlib.vitro.webapp.dao.VClassGroupsForRequest;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VClassGroupCache;
public class PageDataGetterUtils {
protected static final String DATA_GETTER_MAP = "pageTypeToDataGetterMap";
private static final Log log = LogFactory.getLog(PageDataGetterUtils.class);
public static Map<String,Object> getDataForPage(String pageUri, VitroRequest vreq, ServletContext context) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
//Based on page type get the appropriate data getter
Map<String, Object> page = vreq.getWebappDaoFactory().getPageDao().getPage(pageUri);
Map<String,Object> data = new HashMap<String,Object>();
List<PageDataGetter> dataGetters = getPageDataGetterObjects(vreq, pageUri);
for(PageDataGetter getter: dataGetters) {
try{
Map<String,Object> moreData = null;
moreData = getAdditionalData(pageUri, getter.getType(), page, vreq, getter, context);
if( moreData != null)
data.putAll(moreData);
}catch(Throwable th){
log.error(th,th);
}
}
return data;
}
/**
*
* Convert data to JSON for page uri based on type and related datagetters
* TODO: How to handle different data getters? Will this replace json fields or add to them?
* @throws ClassNotFoundException
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static JSONObject covertDataToJSONForPage(String pageUri, Map<String, Object> data, VitroRequest vreq, ServletContext context) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
//Get PageDataGetter types associated with pageUri
JSONObject rObj = null;
List<PageDataGetter> dataGetters = getPageDataGetterObjects(vreq, pageUri);
for(PageDataGetter getter: dataGetters) {
JSONObject typeObj = null;
try{
typeObj = getter.convertToJSON(data, vreq);
if( typeObj != null) {
//Copy over everything from this type Obj to
//TODO: Review how to handle duplicate keys, etc.
if(rObj != null) {
//For now, just nests as separate entry
rObj.put(getter.getType(), typeObj);
} else {
rObj = typeObj;
}
}
} catch(Throwable th){
log.error(th,th);
}
}
return rObj;
}
public static Map<String,Object> getAdditionalData(
String pageUri, String dataGetterName, Map<String, Object> page, VitroRequest vreq, PageDataGetter getter, ServletContext context) {
if(dataGetterName == null || dataGetterName.isEmpty())
return Collections.emptyMap();
if( getter != null ){
try{
log.debug("Retrieve data for this data getter for " + pageUri);
return getter.getData(context, vreq, pageUri, page);
}catch(Throwable th){
log.error(th,th);
return Collections.emptyMap();
}
} else {
return Collections.emptyMap();
}
}
/***
* For the page, get the actual Data Getters to be employed.
* @throws ClassNotFoundException
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static List<PageDataGetter> getPageDataGetterObjects(VitroRequest vreq, String pageUri) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
List<PageDataGetter> dataGetterObjects = new ArrayList<PageDataGetter>();
List<String> dataGetterClassNames = vreq.getWebappDaoFactory().getPageDao().getDataGetterClass(pageUri);
if( dataGetterClassNames == null )
return Collections.emptyList();
for(String dgClassName: dataGetterClassNames) {
String className = getClassNameFromUri(dgClassName);
Class<?> clz = Class.forName(className);
if( PageDataGetter.class.isAssignableFrom(clz)){
PageDataGetter pg = (PageDataGetter) clz.newInstance();
dataGetterObjects.add(pg);
}// else skip if class does not implement PageDataGetter
}
return dataGetterObjects;
}
//Class URIs returned include "java:" and to instantiate object need to remove java: portion
public static String getClassNameFromUri(String dataGetterClassUri) {
if( !StringUtils.isEmpty(dataGetterClassUri) && dataGetterClassUri.contains("java:")) {
String[] splitArray = dataGetterClassUri.split("java:");
if(splitArray.length > 1) {
return splitArray[1];
}
}
return dataGetterClassUri;
}
/**
* Get Individual count for Solr query for intersection of multiple classes
*/
public static long getIndividualCountForIntersection(VitroRequest vreq, ServletContext context, List<String> classUris) {
return IndividualListController.getIndividualCount(classUris, vreq.getWebappDaoFactory().getIndividualDao(), context);
}
/**
* Process results related to VClass or vclasses. Handles both single and multiple vclasses being sent.
*/
public static JSONObject processVclassResultsJSON(Map<String, Object> map, VitroRequest vreq, boolean multipleVclasses) {
JSONObject rObj = new JSONObject();
VClass vclass=null;
try {
// Properties from ontologies used by VIVO - should not be in vitro
DataProperty fNameDp = (new DataProperty());
fNameDp.setURI("http://xmlns.com/foaf/0.1/firstName");
DataProperty lNameDp = (new DataProperty());
lNameDp.setURI("http://xmlns.com/foaf/0.1/lastName");
DataProperty preferredTitleDp = (new DataProperty());
preferredTitleDp.setURI("http://vivoweb.org/ontology/core#preferredTitle");
if( log.isDebugEnabled() ){
@SuppressWarnings("unchecked")
Enumeration<String> e = vreq.getParameterNames();
while(e.hasMoreElements()){
String name = e.nextElement();
log.debug("parameter: " + name);
for( String value : vreq.getParameterValues(name) ){
log.debug("value for " + name + ": '" + value + "'");
}
}
}
//need an unfiltered dao to get firstnames and lastnames
WebappDaoFactory fullWdf = vreq.getUnfilteredWebappDaoFactory();
String[] vitroClassIdStr = vreq.getParameterValues("vclassId");
if ( vitroClassIdStr != null && vitroClassIdStr.length > 0){
for(String vclassId: vitroClassIdStr) {
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 ");
throw new Exception("parameter vclassId URI parameter expected ");
}
List<String> vclassIds = Arrays.asList(vitroClassIdStr);
//if single vclass expected, then include vclass. This relates to what the expected behavior is, not size of list
if(!multipleVclasses) {
//currently used for ClassGroupPage
rObj.put("vclass",
new JSONObject().put("URI",vclass.getURI())
.put("name",vclass.getName()));
} else {
//For now, utilize very last VClass (assume that that is the one to be employed)
//TODO: Find more general way of dealing with this
//put multiple ones in?
if(vclassIds.size() > 0) {
int numberVClasses = vclassIds.size();
vclass = vreq.getWebappDaoFactory().getVClassDao().getVClassByURI(vclassIds.get(numberVClasses - 1));
rObj.put("vclass", new JSONObject().put("URI",vclass.getURI())
.put("name",vclass.getName()));
}
// rObj.put("vclasses", new JSONObject().put("URIs",vitroClassIdStr)
// .put("name",vclass.getName()));
}
if (vclass != null) {
rObj.put("totalCount", map.get("totalCount"));
rObj.put("alpha", map.get("alpha"));
List<Individual> inds = (List<Individual>)map.get("entities");
log.debug("Number of individuals returned from request: " + inds.size());
JSONArray jInds = new JSONArray();
for(Individual ind : inds ){
JSONObject jo = new JSONObject();
jo.put("URI", ind.getURI());
jo.put("label",ind.getRdfsLabel());
jo.put("name",ind.getName());
jo.put("thumbUrl", ind.getThumbUrl());
jo.put("imageUrl", ind.getImageUrl());
jo.put("profileUrl", UrlBuilder.getIndividualProfileUrl(ind, vreq));
jo.put("mostSpecificTypes", JsonServlet.getMostSpecificTypes(ind,fullWdf));
jo.put("preferredTitle", JsonServlet.getDataPropertyValue(ind, preferredTitleDp, fullWdf));
jInds.put(jo);
}
rObj.put("individuals", jInds);
JSONArray wpages = new JSONArray();
//Made sure that PageRecord here is SolrIndividualListController not IndividualListController
List<PageRecord> pages = (List<PageRecord>)map.get("pages");
for( PageRecord pr: pages ){
JSONObject p = new JSONObject();
p.put("text", pr.text);
p.put("param", pr.param);
p.put("index", pr.index);
wpages.put( p );
}
rObj.put("pages",wpages);
JSONArray jletters = new JSONArray();
List<String> letters = Controllers.getLetters();
for( String s : letters){
JSONObject jo = new JSONObject();
jo.put("text", s);
jo.put("param", "alpha=" + URLEncoder.encode(s, "UTF-8"));
jletters.put( jo );
}
rObj.put("letters", jletters);
}
} catch(Exception ex) {
log.error("Error occurred in processing JSON object", ex);
}
return rObj;
}
/*
* Copied from JSONServlet as expect this to be related to VitroClassGroup
*/
public static JSONObject processVClassGroupJSON(VitroRequest vreq, ServletContext context, VClassGroup vcg) {
JSONObject map = new JSONObject();
try {
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());
} catch(Exception ex) {
log.error("Error occurred in processing VClass group ", ex);
}
return map;
}
//Get All VClass Groups information
//Used within menu management and processing
//TODO: Check if more appropriate location possible
public static List<HashMap<String, String>> getClassGroups(HttpServletRequest req) {
//Wanted this to be
VClassGroupsForRequest vcgc = VClassGroupCache.getVClassGroups(req);
List<VClassGroup> vcgList = vcgc.getGroups();
//For now encoding as hashmap with label and URI as trying to retrieve class group
//results in errors for some reason
List<HashMap<String, String>> classGroups = new ArrayList<HashMap<String, String>>();
for(VClassGroup vcg: vcgList) {
HashMap<String, String> hs = new HashMap<String, String>();
hs.put("publicName", vcg.getPublicName());
hs.put("URI", vcg.getURI());
classGroups.add(hs);
}
return classGroups;
}
//Return data getter type to be employed in display model
public static String generateDataGetterTypeURI(String dataGetterClassName) {
return "java:" + dataGetterClassName;
}
//TODO: Check whether this needs to be put here or elsewhere, as this is data getter specific
//with respect to class groups
//Need to use VClassGroupCache to retrieve class group information - this is the information returned from "for class group"
public static void getClassGroupForDataGetter(HttpServletRequest req, Map<String, Object> pageData, Map<String, Object> templateData) {
//Get the class group from VClassGroup, this is the same as the class group for the class group page data getter
//and the associated class group (not custom) for individuals datagetter
String classGroupUri = (String) pageData.get("classGroupUri");
VClassGroupsForRequest vcgc = VClassGroupCache.getVClassGroups(req);
VClassGroup group = vcgc.getGroup(classGroupUri);
templateData.put("classGroup", group);
templateData.put("associatedPage", group.getPublicName());
templateData.put("associatedPageURI", group.getURI());
}
}

8
webapp/src/edu/cornell/mannlib/vitro/webapp/web/directives/IndividualShortViewDirective.java
View file

@ -77,10 +77,10 @@ public class IndividualShortViewDirective extends BaseTemplateDirectiveModel {
private void renderShortView(Individual individual,
ShortViewContext svContext) {
Environment env = Environment.getCurrentEnvironment();
HttpServletRequest request = (HttpServletRequest) env
.getCustomAttribute("request");
ServletContext ctx = request.getSession().getServletContext();
ServletContext ctx = (ServletContext) env.getCustomAttribute("context");
VitroRequest vreq = new VitroRequest(
(HttpServletRequest) env.getCustomAttribute("request"));
ShortViewService svs = ShortViewServiceSetup.getService(ctx);
if (svs == null) {
log.warn("ShortViewService was not initialized properly.");
@ -88,7 +88,7 @@ public class IndividualShortViewDirective extends BaseTemplateDirectiveModel {
}
TemplateAndSupplementalData svInfo = svs.getShortViewInfo(individual,
svContext, vreq);
svContext, new VitroRequest(request));
ObjectWrapper objectWrapper = env.getConfiguration().getObjectWrapper();

13
webapp/src/edu/cornell/mannlib/vitro/webapp/web/widgets/Widget.java
View file

@ -10,7 +10,6 @@ import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.logging.Log;
@ -57,7 +56,7 @@ public abstract class Widget {
public String doMarkup(Environment env, Map params) {
HttpServletRequest request = (HttpServletRequest) env.getCustomAttribute("request");
ServletContext context = (ServletContext) env.getCustomAttribute("context");
ServletContext context = request.getSession().getServletContext();
WidgetTemplateValues values = null;
@ -120,15 +119,7 @@ public abstract class Widget {
// We need to give each widget macro template a unique key in the StringTemplateLoader, and check
// if it's already there or else add it. Leave this for later.
Template template = new Template("widget", new StringReader(templateString), env.getConfiguration());
// JB KLUGE The widget is processed in its own environment, which doesn't include these custom attributes.
// JB KLUGE Put them in.
Environment widgetEnv = template.createProcessingEnvironment(map, out);
ServletRequest request = (ServletRequest) env.getCustomAttribute("request");
widgetEnv.setCustomAttribute("request", request);
widgetEnv.setCustomAttribute("context", env.getCustomAttribute("context"));
widgetEnv.setLocale(request.getLocale());
widgetEnv.process();
template.process(map, out);
} catch (Exception e) {
log.error("Could not process widget " + widgetName, e);
}

3
webapp/test/edu/cornell/mannlib/vitro/webapp/controller/freemarker/ImageUploaderThumbnailerTester_2.java
View file

@ -23,7 +23,6 @@ import java.util.Set;
import javax.media.jai.JAI;
import javax.media.jai.RenderedOp;
import javax.media.jai.operator.StreamDescriptor;
import javax.media.jai.widget.ImageCanvas;
import javax.swing.BorderFactory;
import javax.swing.JPanel;
@ -107,7 +106,7 @@ public class ImageUploaderThumbnailerTester_2 extends Frame {
JPanel p = new JPanel();
p.setLayout(new BorderLayout());
p.add("South", l);
p.add("Center", new ImageCanvas(image));
p.add("Center", new javax.media.jai.widget.ImageCanvas(image));
p.setBackground(new Color(0xFFFFFF));
p.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));

1
webapp/test/edu/cornell/mannlib/vitro/webapp/controller/json/JsonServletTest.java
View file

@ -192,6 +192,7 @@ public class JsonServletTest extends AbstractTestClass {
public void individualsByClassNoIndividuals() throws ServletException,
IOException {
setLoggerLevel(JsonServlet.class, Level.FATAL);
setLoggerLevel(ModelAccess.class, Level.ERROR);
String vclassId = "http://myVclass";
vcDao.setVClass(vclassId, new VClass(vclassId));
req.addParameter(GET_SOLR_INDIVIDUALS_BY_VCLASS, "true");

11
webapp/test/edu/cornell/mannlib/vitro/webapp/utils/dataGetter/DataGetterUtilsTest.java
View file

@ -67,15 +67,6 @@ public class DataGetterUtilsTest extends AbstractTestClass{
}
@Test
public void testNonPageDataGetter() throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, ClassNotFoundException, InvocationTargetException, NoSuchMethodException{
DataGetter dg = DataGetterUtils.dataGetterForURI(vreq, displayModel,dataGetterX);
Assert.assertNull(dg);
List<DataGetter> dgList =
DataGetterUtils.getDataGettersForPage(vreq, displayModel, pageX);
Assert.assertNotNull(dgList);
Assert.assertTrue("List should be, it was not", dgList.size() == 0);
}
}

11
webapp/test/edu/cornell/mannlib/vitro/webapp/utils/dataGetter/resources/dataGetterTest.n3
View file

@ -20,14 +20,5 @@ display:query1data
display:saveToVar "people" .
### test of what happens with a PageDataGetter instead of a DataGetter ###
display:pageX
a display:Page ;
display:title "A PageDataGetter, not a DataGetter" ;
display:urlMapping "/query2" ;
display:hasDataGetter display:pageDataGetterX .
display:pageDataGetterX
a <java:edu.cornell.mannlib.vitro.webapp.utils.pageDataGetter.ClassGroupPageData> .

68
webapp/test/edu/cornell/mannlib/vitro/webapp/utils/pageDataGetter/PageDataGetterUtilsTest.java
View file

@ -1,68 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.utils.pageDataGetter;
import java.io.InputStream;
import java.util.List;
import org.apache.log4j.Level;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import stubs.javax.servlet.http.HttpServletRequestStub;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.ontology.OntModelSpec;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.impl.RDFDefaultErrorHandler;
import edu.cornell.mannlib.vitro.testing.AbstractTestClass;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.SimpleOntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactoryJena;
public class PageDataGetterUtilsTest extends AbstractTestClass{
OntModel displayModel;
WebappDaoFactory wdf;
String pageURI = "http://vitro.mannlib.cornell.edu/ontologies/display/1.1#pageX";
String pageURI_2 = "http://vitro.mannlib.cornell.edu/ontologies/display/1.1#SPARQLPage";
@Before
public void setUp() throws Exception {
// Suppress error logging.
setLoggerLevel(RDFDefaultErrorHandler.class, Level.OFF);
OntModel model = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM);
InputStream in = PageDataGetterUtilsTest.class.getResourceAsStream("resources/pageDataGetter.n3");
model.read(in,"","N3");
displayModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM,model);
SimpleOntModelSelector sos = new SimpleOntModelSelector( ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM));
sos.setDisplayModel(displayModel);
wdf = new WebappDaoFactoryJena(sos);
}
@Test
public void testGetPageDataGetterObjects() throws Exception{
VitroRequest vreq = new VitroRequest( new HttpServletRequestStub() );
ModelAccess.on(vreq).setWebappDaoFactory(wdf);
List<PageDataGetter> pdgList = PageDataGetterUtils.getPageDataGetterObjects(vreq, pageURI);
Assert.assertNotNull(pdgList);
Assert.assertTrue("should have one PageDataGetter", pdgList.size() == 1);
}
@Test
public void testGetNonPageDataGetterObjects() throws Exception{
VitroRequest vreq = new VitroRequest( new HttpServletRequestStub() );
ModelAccess.on(vreq).setWebappDaoFactory(wdf);
List<PageDataGetter> pdgList = PageDataGetterUtils.getPageDataGetterObjects(vreq, pageURI_2);
Assert.assertNotNull(pdgList);
Assert.assertTrue("should have no PageDataGetters", pdgList.size() == 0);
}
}

30
webapp/test/edu/cornell/mannlib/vitro/webapp/utils/pageDataGetter/resources/pageDataGetter.n3
View file

@ -1,30 +0,0 @@
# $This file is distributed under the terms of the license in /doc/license.txt$
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix display: <http://vitro.mannlib.cornell.edu/ontologies/display/1.1#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix core: <http://vivoweb.org/ontology/core#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
### This file is for the test PageDataGetterUtilsTest.java
display:SPARQLPage
a display:Page ;
display:title "TestQuery" ;
display:urlMapping "/query1" ;
display:hasDataGetter display:query1data .
display:query1data
a <java:edu.cornell.mannlib.vitro.webapp.utils.dataGetter.SparqlQueryDataGetter>;
display:query "SELECT * WHERE { ?uri a <http://xmlns.com/foaf/0.1/Person> } " ;
display:saveToVar "people" .
display:pageX
a display:Page ;
display:title "A PageDataGetter, not a DataGetter" ;
display:urlMapping "/query2" ;
display:hasDataGetter display:pageDataGetterX .
display:pageDataGetterX
a <java:edu.cornell.mannlib.vitro.webapp.utils.pageDataGetter.ClassGroupPageData> .

4
webapp/test/stubs/javax/servlet/ServletContextStub.java
View file

@ -200,6 +200,7 @@ public class ServletContextStub implements ServletContext {
}
@Override
@Deprecated
public Servlet getServlet(String arg0) throws ServletException {
throw new RuntimeException(
"ServletContextStub.getServlet() not implemented.");
@ -213,6 +214,7 @@ public class ServletContextStub implements ServletContext {
@Override
@SuppressWarnings("rawtypes")
@Deprecated
public Enumeration getServletNames() {
throw new RuntimeException(
"ServletContextStub.getServletNames() not implemented.");
@ -220,6 +222,7 @@ public class ServletContextStub implements ServletContext {
@Override
@SuppressWarnings("rawtypes")
@Deprecated
public Enumeration getServlets() {
throw new RuntimeException(
"ServletContextStub.getServlets() not implemented.");
@ -231,6 +234,7 @@ public class ServletContextStub implements ServletContext {
}
@Override
@Deprecated
public void log(Exception arg0, String arg1) {
throw new RuntimeException("ServletContextStub.log() not implemented.");
}

57
webapp/test/stubs/javax/servlet/http/HttpServletRequestStub.java
View file

@ -60,8 +60,8 @@ public class HttpServletRequestStub implements HttpServletRequest {
/**
* Supply the request URL as a single URL. We will parse it on the
* assumption that the contextPath and the pathInfo are empty.
* Don't include a query string. Instead, set parameters.
* assumption that the contextPath and the pathInfo are empty. Don't include
* a query string. Instead, set parameters.
*/
public void setRequestUrl(URL url) {
this.contextPath = "";
@ -81,8 +81,7 @@ public class HttpServletRequestStub implements HttpServletRequest {
/**
* Supply the pieces of the request URL, so we can respond correctly when
* asked for a piece.
* Don't include a query string. Instead, set parameters.
* asked for a piece. Don't include a query string. Instead, set parameters.
*/
public void setRequestUrlByParts(String shemeHostPort, String contextPath,
String servletPath, String pathInfo) {
@ -102,8 +101,9 @@ public class HttpServletRequestStub implements HttpServletRequest {
}
this.servletPath = servletPath;
this.requestUri = contextPath + servletPath + ((pathInfo == null) ? "" : pathInfo);
this.requestUri = contextPath + servletPath
+ ((pathInfo == null) ? "" : pathInfo);
if (shemeHostPort == null) {
throw new NullPointerException("shemeHostPort may not be null.");
}
@ -183,21 +183,21 @@ public class HttpServletRequestStub implements HttpServletRequest {
public String getServletPath() {
return servletPath;
}
@Override
public String getPathInfo() {
return pathInfo;
}
@Override
public String getQueryString() {
if (parameters.isEmpty()) {
return null;
}
String qs = "";
for (String key:parameters.keySet()) {
for (String value: parameters.get(key)) {
for (String key : parameters.keySet()) {
for (String value : parameters.get(key)) {
qs += "&" + key + "=" + URLEncoder.encode(value);
}
}
@ -302,167 +302,202 @@ public class HttpServletRequestStub implements HttpServletRequest {
// Un-implemented methods
// ----------------------------------------------------------------------
@Override
public String getAuthType() {
throw new RuntimeException(
"HttpServletRequestStub.getAuthType() not implemented.");
}
@Override
public Cookie[] getCookies() {
throw new RuntimeException(
"HttpServletRequestStub.getCookies() not implemented.");
}
@Override
public long getDateHeader(String arg0) {
throw new RuntimeException(
"HttpServletRequestStub.getDateHeader() not implemented.");
}
@Override
public int getIntHeader(String arg0) {
throw new RuntimeException(
"HttpServletRequestStub.getIntHeader() not implemented.");
}
@Override
public String getPathTranslated() {
throw new RuntimeException(
"HttpServletRequestStub.getPathTranslated() not implemented.");
}
@Override
public String getRemoteUser() {
throw new RuntimeException(
"HttpServletRequestStub.getRemoteUser() not implemented.");
}
@Override
public String getRequestedSessionId() {
throw new RuntimeException(
"HttpServletRequestStub.getRequestedSessionId() not implemented.");
}
@Override
public Principal getUserPrincipal() {
throw new RuntimeException(
"HttpServletRequestStub.getUserPrincipal() not implemented.");
}
@Override
public boolean isRequestedSessionIdFromCookie() {
throw new RuntimeException(
"HttpServletRequestStub.isRequestedSessionIdFromCookie() not implemented.");
}
@Override
public boolean isRequestedSessionIdFromURL() {
throw new RuntimeException(
"HttpServletRequestStub.isRequestedSessionIdFromURL() not implemented.");
}
@Override
@Deprecated
public boolean isRequestedSessionIdFromUrl() {
throw new RuntimeException(
"HttpServletRequestStub.isRequestedSessionIdFromUrl() not implemented.");
}
@Override
public boolean isRequestedSessionIdValid() {
throw new RuntimeException(
"HttpServletRequestStub.isRequestedSessionIdValid() not implemented.");
}
@Override
public boolean isUserInRole(String arg0) {
throw new RuntimeException(
"HttpServletRequestStub.isUserInRole() not implemented.");
}
@Override
public String getCharacterEncoding() {
throw new RuntimeException(
"HttpServletRequestStub.getCharacterEncoding() not implemented.");
}
@Override
public int getContentLength() {
throw new RuntimeException(
"HttpServletRequestStub.getContentLength() not implemented.");
}
@Override
public String getContentType() {
throw new RuntimeException(
"HttpServletRequestStub.getContentType() not implemented.");
}
@Override
public ServletInputStream getInputStream() throws IOException {
throw new RuntimeException(
"HttpServletRequestStub.getInputStream() not implemented.");
}
@Override
public String getLocalAddr() {
throw new RuntimeException(
"HttpServletRequestStub.getLocalAddr() not implemented.");
}
@Override
public String getLocalName() {
throw new RuntimeException(
"HttpServletRequestStub.getLocalName() not implemented.");
}
@Override
public int getLocalPort() {
throw new RuntimeException(
"HttpServletRequestStub.getLocalPort() not implemented.");
}
@Override
public Locale getLocale() {
throw new RuntimeException(
"HttpServletRequestStub.getLocale() not implemented.");
}
@Override
@SuppressWarnings("rawtypes")
public Enumeration getLocales() {
throw new RuntimeException(
"HttpServletRequestStub.getLocales() not implemented.");
}
@Override
public String getProtocol() {
throw new RuntimeException(
"HttpServletRequestStub.getProtocol() not implemented.");
}
@Override
public BufferedReader getReader() throws IOException {
throw new RuntimeException(
"HttpServletRequestStub.getReader() not implemented.");
}
@Override
@Deprecated
public String getRealPath(String arg0) {
throw new RuntimeException(
"HttpServletRequestStub.getRealPath() not implemented.");
}
@Override
public String getRemoteHost() {
throw new RuntimeException(
"HttpServletRequestStub.getRemoteHost() not implemented.");
}
@Override
public int getRemotePort() {
throw new RuntimeException(
"HttpServletRequestStub.getRemotePort() not implemented.");
}
@Override
public RequestDispatcher getRequestDispatcher(String arg0) {
throw new RuntimeException(
"HttpServletRequestStub.getRequestDispatcher() not implemented.");
}
@Override
public String getScheme() {
throw new RuntimeException(
"HttpServletRequestStub.getScheme() not implemented.");
}
@Override
public String getServerName() {
throw new RuntimeException(
"HttpServletRequestStub.getServerName() not implemented.");
}
@Override
public int getServerPort() {
throw new RuntimeException(
"HttpServletRequestStub.getServerPort() not implemented.");
}
@Override
public boolean isSecure() {
throw new RuntimeException(
"HttpServletRequestStub.isSecure() not implemented.");
}
@Override
public void setCharacterEncoding(String arg0)
throws UnsupportedEncodingException {
throw new RuntimeException(

4
webapp/test/stubs/javax/servlet/http/HttpSessionStub.java
View file

@ -126,12 +126,14 @@ public class HttpSessionStub implements HttpSession {
}
@Override
@Deprecated
public Object getValue(String arg0) {
throw new RuntimeException(
"HttpSessionStub.getValue() not implemented.");
}
@Override
@Deprecated
public String[] getValueNames() {
throw new RuntimeException(
"HttpSessionStub.getValueNames() not implemented.");
@ -149,12 +151,14 @@ public class HttpSessionStub implements HttpSession {
}
@Override
@Deprecated
public void putValue(String arg0, Object arg1) {
throw new RuntimeException(
"HttpSessionStub.putValue() not implemented.");
}
@Override
@Deprecated
public void removeValue(String arg0) {
throw new RuntimeException(
"HttpSessionStub.removeValue() not implemented.");

92
webapp/web/templates/freemarker/edit/forms/js/customFormWithAutocomplete.js
View file

@ -55,7 +55,12 @@ var customForm = {
// the verify popup window. Although there could be multiple verifyMatch objects
// selecting one and binding the event works for all of them
this.verifyMatch = this.form.find('.verifyMatch');
this.defaultAcType = ""; // will be set in setType() first time through
this.templateDefinedAcTypes = false;
if ( this.acTypes != undefined ) {
this.templateDefinedAcTypes = true;
}
// find all the acSelector input elements
this.acSelectors = [] ;
@ -86,7 +91,7 @@ var customForm = {
// Used with the cancel link. If the user cancels after a type selection, this check
// ensures that any a/c fields (besides the one associated with the type) will be reset
this.clearAcSelections = false;
},
// Set up the form on page load
@ -126,6 +131,10 @@ var customForm = {
this.initFormView();
// Set the initial autocomplete help text in the acSelector fields.
$.each(this.acSelectors, function() {
customForm.addAcHelpText($(this));
});
},
initFormView: function() {
@ -288,7 +297,7 @@ var customForm = {
//to the filtering list
this.getAcFilterForIndividuals();
this.acCache = {};
$(selectedObj).autocomplete({
minLength: 3,
source: function(request, response) {
@ -312,8 +321,9 @@ var customForm = {
},
complete: function(xhr, status) {
// Not sure why, but we need an explicit json parse here.
var results = $.parseJSON(xhr.responseText),
var results = $.parseJSON(xhr.responseText),
filteredResults = customForm.filterAcResults(results);
customForm.acCache[request.term] = filteredResults;
response(filteredResults);
}
@ -321,6 +331,9 @@ var customForm = {
},
select: function(event, ui) {
customForm.showAutocompleteSelection(ui.item.label, ui.item.uri, $(selectedObj));
if ( $(selectedObj).attr('acGroupName') == customForm.typeSelector.attr('acGroupName') ) {
customForm.typeSelector.val(ui.item.msType);
}
}
});
},
@ -420,17 +433,24 @@ var customForm = {
// provides a way to monitor selection in other js files, e.g. to hide fields upon selection
$acDiv.addClass("userSelected");
// If the form has a type selector, add type name to label in add mode. In edit mode, use typeSelectorSpan
// html. The second case is an "else if" and not an else because the template may not be passing the label
// to the acSelection macro or it may not be using the macro at all and the label is hard-coded in the html.
if ( this.typeSelector.length && ($acDiv.attr('acGroupName') == this.typeSelector.attr('acGroupName')) ) {
$acDiv.find('label').html('Selected ' + this.typeName + ':');
}
else if ( this.typeSelectorSpan.html() && ($acDiv.attr('acGroupName') == this.typeSelectorInput.attr('acGroupName')) ) {
$acDiv.find('label').html('Selected ' + this.typeSelectorSpan.html() + ':');
}
else if ( $acDiv.find('label').html() == '' ) {
$acDiv.find('label').html('Selected ' + this.multipleTypeNames[$(selectedObj).attr('acGroupName')] + ':');
// If the form has a type selector, add type name to label in add mode. In edit mode,
// use typeSelectorSpan html. The second case is an "else if" and not an else because
// the template may not be passing the label to the acSelection macro or it may not be
// using the macro at all and the label is hard-coded in the html.
// ** With release 1.6 and display of all fields, more labels are hard-coded in html.
// ** So check if there's a label before doing anything else.
if ( $acDiv.find('label').html().length === 0 ) {
if ( this.typeSelector.length && ($acDiv.attr('acGroupName') == this.typeSelector.attr('acGroupName')) ) {
$acDiv.find('label').html('Selected ' + this.typeName + ':');
}
else if ( this.typeSelectorSpan.html() && ($acDiv.attr('acGroupName') == this.typeSelectorInput.attr('acGroupName')) ) {
$acDiv.find('label').html('Selected ' + this.typeSelectorSpan.html() + ':');
}
else if ( $acDiv.find('label').html() == '' ) {
$acDiv.find('label').html('Selected ' + this.multipleTypeNames[$(selectedObj).attr('acGroupName')] + ':');
}
}
$acDiv.show();
@ -447,7 +467,6 @@ var customForm = {
//On initialization in this mode, submit button is disabled
this.enableSubmit();
}
},
undoAutocompleteSelection: function(selectedObj) {
@ -482,11 +501,12 @@ var customForm = {
$acSelector = customForm.getAcSelector($checkSelection);
$acSelector.parent('p').show();
}
});
}
});
}
}
else {
$acSelectionObj = $(selectedObj);
customForm.typeSelector.val('');
}
$acSelector = this.getAcSelector($acSelectionObj);
@ -530,10 +550,9 @@ var customForm = {
// Note: we still need this in edit mode, to set the text values.
setType: function() {
var selectedType;
// If there's no type selector, these values have been specified in customFormData,
// and will not change over the life of the form.
if (!this.typeSelector.length) {
if (!this.typeSelector.length) {
if ( this.editMode == 'edit' && (this.typeSelectorSpan.html() != null && this.typeSelectorInput.val() != null) ) {
this.typeName = this.typeSelectorSpan.html();
this.acTypes[this.typeSelectorInput.attr('acGroupName')] = this.typeSelectorInput.val();
@ -542,7 +561,11 @@ var customForm = {
}
selectedType = this.typeSelector.find(':selected');
var acTypeKey = this.typeSelector.attr('acGroupName');
var acTypeKey = this.typeSelector.attr('acGroupName');
if ( this.templateDefinedAcTypes && !this.defaultAcType.length ) {
this.defaultAcType = this.acTypes[acTypeKey];
}
if (selectedType.val().length) {
this.acTypes[acTypeKey] = selectedType.val();
this.typeName = selectedType.html();
@ -551,15 +574,20 @@ var customForm = {
$acSelect.find('label').html( customForm.selectedString + ' ' + this.typeName + ':');
}
}
// reset to empty values; may not need
// reset to empty values;
else {
delete this.acTypes[acTypeKey];
this.typeName = '';
if ( this.templateDefinedAcTypes ) {
this.acTypes[acTypeKey] = this.defaultAcType;
}
else {
this.acTypes = new Object();
}
this.typeName = this.defaultTypeName;
}
},
// Set field labels based on type selection. Although these won't change in edit
// mode, it's easier to specify the text here than in the jsp.
// mode, it's easier to specify the text here than in the ftl.
setLabels: function() {
var typeName = this.getTypeNameForLabels();
@ -575,10 +603,20 @@ var customForm = {
// or in repair mode in a two-step form with no type selected. Use the default type
// name specified in the form data.
if ( !selectedObj || !this.hasMultipleTypeNames ) {
return this.acTypes ? this.typeName : this.capitalize(this.defaultTypeName);
if ( this.acTypes && this.typeName ) {
return this.typeName;
}
else {
return this.capitalize(this.defaultTypeName);
}
}
else if ( selectedObj && ( $(selectedObj).attr('acGroupName') == this.typeSelector.attr('acGroupName') ) ) {
return this.acTypes ? this.typeName : this.capitalize(this.defaultTypeName);
if ( this.acTypes && this.typeName ) {
return this.typeName;
}
else {
return this.capitalize(this.defaultTypeName);
}
}
else {
var name = customForm.multipleTypeNames[$(selectedObj).attr('id')];