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
Show stats Download patch file Download diff file Expand all files Collapse all files

33
doc/install.html
View file

@ -774,6 +774,39 @@
<p>
to build Vitro and deploy to Tomcat's webapps directory.
</p>
<p>
The build script may run for as much as five minutes,
and creates more than 100 lines of output.
The process comprises several steps:
<ul>
<li>collecting the source files from the distribution directory,</li>
<li>compiling the Java source code,</li>
<li>compiling and running unit tests,</li>
<li>preparing the Solr search engine,</li>
<li>deploying Vitro and Solr to Tomcat.</li>
</ul>
</p>
<p>
The output of the build may include a variety of warning messages.
The Java compiler may warn of code that is outdated.
Unit tests may produce warning messages,
and some tests may be ignored if they do not produce consistent results.
</p>
<table align="center"><tr><td>
BUILD SUCCESSFUL<br>Total time: 1 minute 49 seconds
</td></tr></table>
<p>
If the output ends with a success message, the build was successful.
Proceed to the next step.
</p>
<table align="center"><tr><td>
BUILD FAILED<br>Total time: 35 seconds
</td></tr></table>
<p>
If the output ends with a failure message, the build has failed.
Find the cause of the failure, fix the problem, and run the script again.
</p>
<h3 id="tomcat_settings">VII. Configure Tomcat</h3>
<h4>Set JVM parameters</h4>
<p>

9
solr/homeDirectoryTemplate/conf/schema.xml
View file

@ -194,6 +194,9 @@
<field name="classLocalName" type="text" indexed="true" stored="true" multiValued="true"/>
<field name="classgroup" type="string" indexed="true" stored="true" multiValued="true"/>
<field name="mostSpecificTypeURIs" type="string" indexed="true" stored="true" omitNorms="true" multiValued="true"/>
<field name="PROHIBITED_FROM_TEXT_RESULTS" type="string" indexed="true" stored="false" omitNorms="true" multiValued="true"/>
<field name="URI" type="string" indexed="true" stored="true" multiValued="false" omitNorms="true"/>
@ -217,16 +220,10 @@
<field name="ALLTEXT" type="text" indexed="true" stored="true" multiValued="true"/>
<field name="ALLTEXTUNSTEMMED" type="textgen" indexed="true" stored="false" multiValued="true"/>
<field name="ALLTEXT_PHONETIC" type="phonetic" indexed="true" stored="false" multiValued="true"/>
<field name="THUMBNAIL" type="string" indexed="true" stored="true"/>
<field name="BETA" type="float" indexed="true" stored="true" multiValued="false"/>
<!-- <field name="PHI" type="float" indexed="true" stored="true" multiValued="false"/>
<field name="ADJACENT_NODES" type="string" indexed="true" stored="true" multiValued="true"/> -->
<field name="modType" type="ignored"/>
<field name="JCLASS" type="ignored"/>
<!-- field for storing locations of thumbnails -->
<field name="THUMBNAIL_URL" type="string" indexed="false" stored="true"/>

8
webapp/build.xml
View file

@ -188,14 +188,6 @@
<!-- Copy the build.properties file to the resources directory. -->
<copy todir="${main.resources.dir}" file="${build.properties.file}" />
<!-- If there is a runtime.properties file in the same directory as build.properties, copy that too. -->
<dirname file="${build.properties.file}" property="runtime.properties.dir"/>
<copy todir="${main.resources.dir}" >
<fileset dir="${runtime.properties.dir}" >
<filename name="runtime.properties" />
</fileset>
</copy>
<!-- copy any xml files from source tree to the war directory -->
<copy todir="${main.compiled.dir}">
<fileset dir="${appbase.dir}/src" includes="**/*.xml" />

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) {

214
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 {
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);
}
@ -86,28 +113,183 @@ public abstract class FileUploadServletRequest extends HttpServletRequestWrapper
/** Was this a multipart HTTP request? */
public abstract boolean isMultipart();
/**
* Get the map of file items, by name.
*/
public abstract Map<String, List<FileItem>> getFiles();
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);
}
/**
* 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.
* Pull any parameters out of the URL.
*/
public abstract FileItem getFileItem(String string);
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);
}
/**
* Was there an exception when uploading the file items?
* Remove any special URL-style encoding.
*/
public abstract boolean hasFileUploadException();
private String decode(String encoded) {
try {
return URLDecoder.decode(encoded, "UTF-8");
} catch (UnsupportedEncodingException e) {
log.error(e, e);
return encoded;
}
}
/** 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;
}
/**
* Get the exception that occurred when uploading the file items. If no such
* exception, return <code>null</code>.
* {@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 abstract FileUploadException getFileUploadException();
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;
}
}

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

@ -33,34 +33,9 @@ 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);
}
/**
* Parse the multipart request. Store the info about the request parameters
* and the uploaded files to a temporary directory.
@ -71,92 +46,15 @@ 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);
//use an upload handler that will stash the file items in a temporary directory.
ServletFileUpload upload = createUploadHandler( this.maxFileSize, this.tempDir );
stashParametersInRequest( request , upload );
}
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;
}
}
/**
* Find the temporary storage directory for this webapp.
@ -166,18 +64,6 @@ public class MultipartHttpServletRequest extends FileUploadServletRequest {
"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;
}
}

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

@ -33,25 +33,6 @@ 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
@ -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;
}
}

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

@ -3,30 +3,34 @@
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 */
/** 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";
/** Modtime from db */
public static String MODTIME = "modTime";
/** 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";
/** 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 **/
@ -45,6 +49,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";
}

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

@ -116,8 +116,20 @@ 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());
@ -153,9 +165,7 @@ public class AutocompleteController extends VitroAjaxController {
SolrQuery query = new SolrQuery();
query.setStart(0)
.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);
@ -163,7 +173,7 @@ public class AutocompleteController extends VitroAjaxController {
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);
@ -188,8 +198,6 @@ public class AutocompleteController extends VitroAjaxController {
String filterQuery = StringUtils.join(filterQueries, " OR ");
query.addFilterQuery(filterQuery);
}
}
private void setNameQuery(SolrQuery query, String queryStr, HttpServletRequest request) {
@ -197,7 +205,6 @@ public class AutocompleteController extends VitroAjaxController {
if (StringUtils.isBlank(queryStr)) {
log.error("No query string");
}
String tokenizeParam = (String) request.getParameter("tokenize");
boolean tokenize = "true".equals(tokenizeParam);
@ -292,10 +299,12 @@ public class AutocompleteController extends VitroAjaxController {
public class SearchResult implements Comparable<Object> {
private String label;
private String uri;
private String msType;
SearchResult(String label, String uri) {
SearchResult(String label, String uri, String msType) {
this.label = label;
this.uri = uri;
this.msType = msType;
}
public String getLabel() {
@ -314,10 +323,18 @@ public class AutocompleteController extends VitroAjaxController {
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");

12
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);
}
@ -287,6 +287,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 = "";
String label = ind.getRdfsLabel();

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(

102
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();
StartupStatus ss = StartupStatus.getBean(ctx);
// 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;
}
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,22 +134,55 @@ 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
public void migrateDisplayModel(UpdateSettings settings) throws Exception {
@ -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");

9
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);
}
}

9
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.");
}

45
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,7 +101,8 @@ 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.");
@ -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.");

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

@ -55,6 +55,11 @@ 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 = [] ;
@ -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() {
@ -314,6 +323,7 @@ var customForm = {
// Not sure why, but we need an explicit json parse here.
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,9 +433,15 @@ 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 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 + ':');
}
@ -432,6 +451,7 @@ var customForm = {
else if ( $acDiv.find('label').html() == '' ) {
$acDiv.find('label').html('Selected ' + this.multipleTypeNames[$(selectedObj).attr('acGroupName')] + ':');
}
}
$acDiv.show();
$acDiv.find("input").val(uri);
@ -447,7 +467,6 @@ var customForm = {
//On initialization in this mode, submit button is disabled
this.enableSubmit();
}
},
undoAutocompleteSelection: function(selectedObj) {
@ -487,6 +506,7 @@ var customForm = {
}
else {
$acSelectionObj = $(selectedObj);
customForm.typeSelector.val('');
}
$acSelector = this.getAcSelector($acSelectionObj);
@ -530,7 +550,6 @@ 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) {
@ -543,6 +562,10 @@ var customForm = {
selectedType = this.typeSelector.find(':selected');
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')];