diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/HomePageController.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/HomePageController.java index ed4a31a78..ce4ca742d 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/HomePageController.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/HomePageController.java @@ -3,14 +3,17 @@ package edu.cornell.mannlib.vitro.webapp.controller.freemarker; import java.util.HashMap; +import java.util.List; import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import edu.cornell.mannlib.vitro.webapp.beans.VClassGroup; import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest; import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.ResponseValues; import edu.cornell.mannlib.vitro.webapp.controller.freemarker.responsevalues.TemplateResponseValues; +import edu.cornell.mannlib.vitro.webapp.dao.jena.VClassGroupCache; public class HomePageController extends FreemarkerHttpServlet { @@ -22,7 +25,11 @@ public class HomePageController extends FreemarkerHttpServlet { @Override protected ResponseValues processRequest(VitroRequest vreq) { - Map body = new HashMap(); + Map body = new HashMap(); + VClassGroupCache vcgc = VClassGroupCache.getVClassGroupCache( getServletContext() ); + List vClassGroups = vcgc.getGroups(vreq.getPortalId()); + body.put("vClassGroups", vClassGroups); + // Add home page data to body here return new TemplateResponseValues(BODY_TEMPLATE, body); } diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/DisplayVocabulary.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/DisplayVocabulary.java index aa224e9c6..56bf9e008 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/DisplayVocabulary.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/DisplayVocabulary.java @@ -13,7 +13,7 @@ public class DisplayVocabulary { public static final String PAGE_TYPE = NS + "Page"; public static final String HOME_PAGE_TYPE = NS + "HomePage"; public static final String CLASSGROUP_PAGE_TYPE = NS + "ClassGroupPage"; - + /* Object Properties */ public static final String FOR_CLASSGROUP = NS + "forClassGroup"; diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/VitroVocabulary.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/VitroVocabulary.java index ec9bae539..beb2442a8 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/VitroVocabulary.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/VitroVocabulary.java @@ -296,4 +296,31 @@ public class VitroVocabulary { public static final String IND_MAIN_IMAGE = VITRO_PUBLIC + "mainImage"; public static final String IND_IMAGE = VITRO_PUBLIC + "image"; + // =============== Date Time with Precision vocabulary =============== + private static final String DATETIME_NS = "http://vivoweb.org/ontology/core#"; + + protected static final String[] PRECISIONS = { + DATETIME_NS+"NoPrecision", + DATETIME_NS+"YearPrecision", + DATETIME_NS+"YearMonthPrecision", + DATETIME_NS+"YearMonthDayPrecision", + DATETIME_NS+"YearMonthDayHourPrecision", + DATETIME_NS+"YearMonthDayHourMinutePrecision", + DATETIME_NS+"YearMonthDayTimePrecision"}; + + public enum Precision { + NONE(PRECISIONS[0]), + YEAR(PRECISIONS[1]), + MONTH(PRECISIONS[2]), + DAY(PRECISIONS[3]), + HOUR(PRECISIONS[4]), + MINUTE(PRECISIONS[5]), + SECOND(PRECISIONS[6]); + + private final String URI; + Precision(String uri){ + URI=uri; + } + public String uri(){return URI;} + } } diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/edit/elements/DateTimeWithPrecision.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/edit/elements/DateTimeWithPrecision.java new file mode 100644 index 000000000..4f3673b40 --- /dev/null +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/edit/elements/DateTimeWithPrecision.java @@ -0,0 +1,468 @@ +/* $This file is distributed under the terms of the license in /doc/license.txt$ */ + +package edu.cornell.mannlib.vitro.webapp.edit.elements; + +import java.util.Calendar; +import java.util.Collections; +import java.util.Date; +import java.util.HashMap; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.joda.time.DateTime; + +import com.hp.hpl.jena.rdf.model.Literal; +import com.hp.hpl.jena.rdf.model.Model; +import com.hp.hpl.jena.rdf.model.ModelFactory; + +import edu.cornell.mannlib.vitro.webapp.controller.freemarker.FreemarkerHttpServlet; +import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary; +import edu.cornell.mannlib.vitro.webapp.edit.n3editing.EditConfiguration; +import edu.cornell.mannlib.vitro.webapp.edit.n3editing.EditSubmission; +import edu.cornell.mannlib.vitro.webapp.edit.n3editing.Field; +import freemarker.template.Configuration; + +/** + * This is intended to work in conjunction with a template to create the HTML for a + * datetime with precision and to convert he submitted parameters into + * varname -> Literal and varname -> URI maps. + * + * This requires two variables to be defined: + * ${fieldname}.precision - URI of datetime precision + * ${fieldname}.value - DateTime literal + * + */ +public class DateTimeWithPrecision extends BaseEditElement { + + String fieldName; + VitroVocabulary.Precision requiredMinimumPrecision; + + + VitroVocabulary.Precision DEFAULT_MIN_PRECISION = VitroVocabulary.Precision.DAY; + VitroVocabulary.Precision[] precisions = VitroVocabulary.Precision.values(); + + public DateTimeWithPrecision(Field field) { + super(field); + fieldName = field.getName(); + requiredMinimumPrecision = DEFAULT_MIN_PRECISION; + } + + public DateTimeWithPrecision(Field field, VitroVocabulary.Precision requiredMinimumPrecision){ + this(field); + if( requiredMinimumPrecision != null ) + this.requiredMinimumPrecision = requiredMinimumPrecision; + else + requiredMinimumPrecision = DEFAULT_MIN_PRECISION; + } + + //it would be nice to have only the version of the constructor that takes the enum + //but this is to quickly get the JSP configuration working. + public DateTimeWithPrecision(Field field, String precisionURI){ + this(field); + for( VitroVocabulary.Precision precision : VitroVocabulary.Precision.values()){ + if( precision.uri().equals(precisionURI)) + this.requiredMinimumPrecision = precision; + } + if( this.requiredMinimumPrecision == null ) + throw new IllegalArgumentException(precisionURI +" is not a valid precision, see VitroVocabulary.Precision"); + } + + private static final Log log = LogFactory.getLog(DateTimeWithPrecision.class); + protected String TEMPATE_NAME = "DateTimeWithPrecision.ftl"; + + @Override + public String draw(String fieldName, EditConfiguration editConfig, + EditSubmission editSub, Configuration fmConfig) { + Map map = getMapForTemplate( editConfig, editSub); + map.putAll( FreemarkerHttpServlet.getDirectives()); + return merge( fmConfig, TEMPATE_NAME, map); + } + + /** + * This produces a map for use in the template. + */ + private Map getMapForTemplate(EditConfiguration editConfig, EditSubmission editSub) { + Mapmap = new HashMap(); + + map.put("fieldName", fieldName); + + DateTime value = getTimeValue(editConfig,editSub); + map.put("year", Integer.toString(value.getYear())); + map.put("month", Integer.toString(value.getMonthOfYear())); + map.put("day", Integer.toString(value.getDayOfMonth()) ); + map.put("hour", Integer.toString(value.getHourOfDay()) ); + map.put("minute", Integer.toString(value.getMinuteOfHour()) ); + map.put("second", Integer.toString(value.getSecondOfMinute() )) ; + + map.put("precision", getPrecision(editConfig,editSub)); + map.put("requiredMinimumPrecision", requiredMinimumPrecision.uri()); + + addPrecisionConstants(map); + return map; + } + + /** Adds precisionURIs for use by the templates */ + private void addPrecisionConstants(Map map){ + Map constants = new HashMap(); + for( VitroVocabulary.Precision pc: VitroVocabulary.Precision.values()){ + constants.put(pc.name().toLowerCase(),pc.uri()); + } + map.put("precisions", constants); + } + + /** + * Gets the currently set precision + */ + private String getPrecision(EditConfiguration editConfig, EditSubmission editSub) { + String precisionURI = editConfig.getUrisInScope().get( getPrecisionVariableName() ); + if( precisionURI == null ){ + //maybe we need a way to specify a default value? + return VitroVocabulary.Precision.DAY.uri(); + }else{ + return precisionURI; + } + } + + private DateTime getTimeValue(EditConfiguration editConfig, EditSubmission editSub) { + Literal dtValue = editConfig.getLiteralsInScope().get( getValueVariableName() ); + if( dtValue == null ){ + //maybe we need a way to specify a default value? + return new DateTime(); + }else{ + return new DateTime( dtValue.getLexicalForm() ); + } + } + + /** + * This gets the literals for a submitted form from the queryParmeters. + * It will only be called if getValidationErrors() doesn't return any errors. + */ + @Override + public Map getLiterals(String fieldName, + EditConfiguration editConfig, Map queryParameters) { + Map literalMap = new HashMap(); + + Literal datetime =getDateTime( queryParameters); + literalMap.put(fieldName+".value", datetime); + + return literalMap; + } + + protected Literal getDateTime( Map queryParameters ) { + Integer year = parseToInt(fieldName+".year", queryParameters); + Integer month = parseToInt(fieldName+".month", queryParameters); + if( month == null || month == 0 ) + month = 1; + Integer day = parseToInt(fieldName+".day", queryParameters); + if( day == null || day == 0 ) + day = 1; + Integer hour = parseToInt(fieldName+".hour", queryParameters); + if( hour == null ) + hour = 0; + Integer minute = parseToInt(fieldName+".minute", queryParameters); + if( minute == null ) + minute = 0; + Integer second = parseToInt(fieldName+".second", queryParameters); + if( second == null ) + second = 0; + int mills = 0; + + + DateTime value = new DateTime( + year.intValue(),month.intValue(),day.intValue(), + hour.intValue(),minute.intValue(),second.intValue(),mills); + + Date dValue = value.toDate(); + + /*This isn't doing what I want it to do. It is recording the correct instance of timeb + * but it is recording it with the timezone UTC/zulu */ + //return ResourceFactory.createTypedLiteral(ISODateTimeFormat.dateTimeNoMillis().print(value),XSDDatatype.XSDdateTime); + + Calendar c = Calendar.getInstance(); + c.setTime(value.toDate()); + + Model m = ModelFactory.createDefaultModel(); + Literal lit = m.createTypedLiteral( c ); + return lit; + } + + /** + * This gets the URIs for a submitted form from the queryParmeters. + * It will only be called if getValidationErrors() doesn't return any errors. + */ + @Override + public Map getURIs(String fieldName, + EditConfiguration editConfig, Map queryParameters) { + String precisionUri; + try { + precisionUri = getSubmittedPrecision( queryParameters); + } catch (Exception e) { + log.error("getURIS() should only be called on input that passed getValidationErrors()"); + return Collections.emptyMap(); + } + Map uriMap = new HashMap(); + uriMap.put(fieldName+".precision", precisionUri); + return uriMap; + } + + /** + * Precision is based on the values returned by the form. Throws an exception with + * the error message if the queryParameters cannot make a valid date/precision because + * there are values missing. + */ + protected String getSubmittedPrecision(Map queryParameters) throws Exception { + + Integer year = parseToInt(fieldName+".year",queryParameters); + Integer month = parseToInt(fieldName+".month",queryParameters); + Integer day = parseToInt(fieldName+".day",queryParameters); + Integer hour = parseToInt(fieldName+".hour",queryParameters); + Integer minute = parseToInt(fieldName+".minute",queryParameters); + Integer second = parseToInt(fieldName+".second",queryParameters); + Integer[] values = { year, month, day, hour, minute, second }; + + /* find the most significant date field that is null. */ + int indexOfFirstNull= -1; + for(int i=0; i < values.length ; i++){ + if( values[i] == null ){ + indexOfFirstNull = i; + break; + } + } + + /* if they all had values then we have seconds precision */ + if( indexOfFirstNull == -1 ) + return VitroVocabulary.Precision.SECOND.uri(); + + + /* check that there are no values after the most significant null field + * that are non-null. */ + boolean nonNullAfterFirstNull=false; + for(int i=0; i < values.length ; i++){ + if( i > indexOfFirstNull && values[i] != null ){ + nonNullAfterFirstNull = true; + break; + } + } + if( nonNullAfterFirstNull ) + throw new Exception("cannot determine precision, there were filledout values after the first un-filledout value, "); + else{ + return precisions[ indexOfFirstNull ].uri(); + } + } + + @Override + public Map getValidationMessages(String fieldName, + EditConfiguration editConfig, Map queryParameters) { + Map errorMsgMap = new HashMap(); + + //check that any parameters we got are single values + String[] names = {"year","month","day","hour","minute","second", "precision"}; + for( String name:names){ + if ( !hasNoneOrSingle(fieldName+"."+name, queryParameters)) + errorMsgMap.put(fieldName+"."+name, "must have only one value for " + name); + } + + String precisionURI = null; + try{ + precisionURI = getSubmittedPrecision( queryParameters); + }catch(Exception ex){ + errorMsgMap.put(fieldName,ex.getMessage()); + return errorMsgMap; + } + + errorMsgMap.putAll(checkDate( precisionURI, queryParameters) ); + + return errorMsgMap; + } + + /** + * This checks for invalid date times. + */ + final static String NON_INTEGER_YEAR = "must enter a valid year"; + final static String NON_INTEGER_MONTH = "must enter a valid month"; + final static String NON_INTEGER_DAY = "must enter a valid day"; + final static String NON_INTEGER_HOUR = "must enter a valid hour"; + final static String NON_INTEGER_MINUTE = "must enter a valid minute"; + final static String NON_INTEGER_SECOND = "must enter a valid second"; + + private Map checkDate( String precisionURI, Map qp){ + if( precisionURI == null ) + return Collections.emptyMap(); + + Map errors = new HashMap(); + + Integer year,month,day,hour,minute,second; + + //just check if the values for the precision parse to integers + if( precisionURI.equals(VitroVocabulary.Precision.YEAR.uri() ) ){ + if( ! canParseToNumber(fieldName+".year" ,qp)) + errors.put(fieldName+".year", NON_INTEGER_YEAR); + }else if( precisionURI.equals( VitroVocabulary.Precision.MONTH.uri() )){ + if( ! canParseToNumber(fieldName+".year" ,qp)) + errors.put(fieldName+".year", NON_INTEGER_YEAR); + if( ! canParseToNumber(fieldName+".month" ,qp)) + errors.put(fieldName+".month", NON_INTEGER_MONTH); + }else if( precisionURI.equals( VitroVocabulary.Precision.DAY.uri() )){ + if( ! canParseToNumber(fieldName+".year" ,qp)) + errors.put(fieldName+".year", NON_INTEGER_YEAR); + if( ! canParseToNumber(fieldName+".month" ,qp)) + errors.put(fieldName+".month", NON_INTEGER_MONTH); + if( ! canParseToNumber(fieldName+".day" ,qp)) + errors.put(fieldName+".day", NON_INTEGER_DAY); + }else if( precisionURI.equals( VitroVocabulary.Precision.HOUR.uri() )){ + if( ! canParseToNumber(fieldName+".year" ,qp)) + errors.put(fieldName+".year", NON_INTEGER_YEAR); + if( ! canParseToNumber(fieldName+".month" ,qp)) + errors.put(fieldName+".month", NON_INTEGER_MONTH); + if( ! canParseToNumber(fieldName+".day" ,qp)) + errors.put(fieldName+".day", NON_INTEGER_DAY); + if( ! canParseToNumber(fieldName+".hour" ,qp)) + errors.put(fieldName+".hour", NON_INTEGER_HOUR); + }else if( precisionURI.equals( VitroVocabulary.Precision.MINUTE.uri() )){ + if( ! canParseToNumber(fieldName+".year" ,qp)) + errors.put(fieldName+".year", NON_INTEGER_YEAR); + if( ! canParseToNumber(fieldName+".month" ,qp)) + errors.put(fieldName+".month", NON_INTEGER_MONTH); + if( ! canParseToNumber(fieldName+".day" ,qp)) + errors.put(fieldName+".day", NON_INTEGER_DAY); + if( ! canParseToNumber(fieldName+".hour" ,qp)) + errors.put(fieldName+".hour", NON_INTEGER_HOUR); + if( ! canParseToNumber(fieldName+".minute" ,qp)) + errors.put(fieldName+".minute", NON_INTEGER_HOUR); + }else if( precisionURI.equals( VitroVocabulary.Precision.SECOND.uri() )){ + if( ! canParseToNumber(fieldName+".year" ,qp)) + errors.put(fieldName+".year", NON_INTEGER_YEAR); + if( ! canParseToNumber(fieldName+".month" ,qp)) + errors.put(fieldName+".month", NON_INTEGER_MONTH); + if( ! canParseToNumber(fieldName+".day" ,qp)) + errors.put(fieldName+".day", NON_INTEGER_DAY); + if( ! canParseToNumber(fieldName+".hour" ,qp)) + errors.put(fieldName+".hour", NON_INTEGER_HOUR); + if( ! canParseToNumber(fieldName+".minute" ,qp)) + errors.put(fieldName+".minute", NON_INTEGER_HOUR); + if( ! canParseToNumber(fieldName+".second" ,qp)) + errors.put(fieldName+".second", NON_INTEGER_SECOND); + } + + //check if we can make a valid date with these integers + year = parseToInt(fieldName+".year", qp); + if( year == null ) + year = 1999; + month= parseToInt(fieldName+".month", qp); + if(month == null ) + month = 1; + day = parseToInt(fieldName+".day", qp); + if( day == null ) + day = 1; + hour = parseToInt(fieldName+".hour", qp); + if( hour == null ) + hour = 0; + minute = parseToInt(fieldName+".minute",qp); + if( minute == null ) + minute = 0; + second = parseToInt(fieldName+".second", qp); + if( second == null ) + second = 0; + + DateTime dateTime = new DateTime(); + try{ + dateTime.withYear(year); + }catch(IllegalArgumentException iae){ + errors.put(fieldName+".year", iae.getLocalizedMessage()); + } + try{ + dateTime.withMonthOfYear(month); + }catch(IllegalArgumentException iae){ + errors.put(fieldName+".month", iae.getLocalizedMessage()); + } + try{ + dateTime.withDayOfMonth(day); + }catch(IllegalArgumentException iae){ + errors.put(fieldName+".day", iae.getLocalizedMessage()); + } + try{ + dateTime.withHourOfDay(hour); + }catch(IllegalArgumentException iae){ + errors.put(fieldName+".hour", iae.getLocalizedMessage()); + } + try{ + dateTime.withSecondOfMinute(second); + }catch(IllegalArgumentException iae){ + errors.put(fieldName+".second", iae.getLocalizedMessage()); + } + + return errors; + } + + + private boolean fieldMatchesPattern( String fieldName, MapqueryParameters, Pattern pattern){ + String[] varg = queryParameters.get(fieldName); + if( varg == null || varg.length != 1 || varg[0] == null) + return false; + String value = varg[0]; + Matcher match = pattern.matcher(value); + return match.matches(); + } + + private boolean emptyOrBlank(String key,Map queryParameters){ + String[] vt = queryParameters.get(key); + return ( vt == null || vt.length ==0 || vt[0] == null || vt[0].length() == 0 ); + } + + private boolean canParseToNumber(String key,Map queryParameters){ + Integer out = null; + try{ + String[] vt = queryParameters.get(key); + if( vt == null || vt.length ==0 || vt[0] == null) + return false; + else{ + out = Integer.parseInt(vt[0]); + return true; + } + }catch(IndexOutOfBoundsException iex){ + out = null; + }catch(NumberFormatException nfe){ + out = null; + }catch(NullPointerException npe){ + out = null; + } + return false; + } + + + + private Integer parseToInt(String key,Map queryParameters){ + Integer out = null; + try{ + String[] vt = queryParameters.get(key); + if( vt == null || vt.length ==0 || vt[0] == null) + out = null; + else + out = Integer.parseInt(vt[0]); + }catch(IndexOutOfBoundsException iex){ + out = null; + }catch(NumberFormatException nfe){ + out = null; + }catch(NullPointerException npe){ + out = null; + } + return out; + } + + public VitroVocabulary.Precision getRequiredMinimumPrecision() { + return requiredMinimumPrecision; + } + + public void setRequiredMinimumPrecision( + VitroVocabulary.Precision requiredMinimumPrecision) { + this.requiredMinimumPrecision = requiredMinimumPrecision; + } + + public String getValueVariableName(){ return fieldName + ".value" ; } + public String getPrecisionVariableName(){ return fieldName + ".precision" ; } +} + + diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/edit/elements/EditElement.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/edit/elements/EditElement.java index 7df85c62e..662c43954 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/edit/elements/EditElement.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/edit/elements/EditElement.java @@ -39,9 +39,9 @@ public interface EditElement { */ public String draw(String fieldName, EditConfiguration editConfig, EditSubmission editSub, Configuration fmConfig); - /** - * We may need a method to get existing URIs and Literals for use in building retraction statements? - */ - // public Map getExistingLiterals(?); - // public Map getExistingURIs(?); + /* in the future, we may need to get existing values */ + /* + public Map getExistingLiterals(???) + public Map getExistingURIs(???); + */ } diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/Field.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/Field.java index d046a90b6..56189ddda 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/Field.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/Field.java @@ -119,7 +119,7 @@ public class Field { * Property for special edit element. */ private EditElement editElement=null;; - + /* *********************** Constructors ************************** */ public Field(String config, String varName) { @@ -163,7 +163,7 @@ public class Field { setLiteralOptions(obj.getJSONArray("literalOptions")); setAssertions(EditConfiguration.JsonArrayToStringList(obj.getJSONArray("assertions"))); - setEditElement( obj, fieldName); + setEditElement( obj, fieldName); //check for odd parameters JSONArray names = obj.names(); @@ -179,7 +179,10 @@ public class Field { } } - + public void setEditElement(EditElement editElement){ + this.editElement = editElement; + } + /** * A field may specify a class for additional features. */ diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/search/beans/Searcher.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/search/beans/Searcher.java index ee9f106d8..6d1fb6e30 100755 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/search/beans/Searcher.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/search/beans/Searcher.java @@ -19,7 +19,7 @@ import edu.cornell.mannlib.vitro.webapp.search.beans.VitroQueryFactory; * * @author bdc34 * - *@deprecated Use LuceneIndexFactory instead + * @ deprecated Use LuceneIndexFactory instead */ public interface Searcher { diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/search/beans/VitroHighlighter.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/search/beans/VitroHighlighter.java index 567a329d8..aaafb4714 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/search/beans/VitroHighlighter.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/search/beans/VitroHighlighter.java @@ -26,7 +26,7 @@ import edu.cornell.mannlib.vitro.webapp.beans.ObjectPropertyStatement; * * @author bdc34 * - * @deprecated there is no replacement + * @ deprecated there is no replacement */ public abstract class VitroHighlighter extends UnaryFunctor { diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/web/jsptags/InputElementFormattingTag.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/web/jsptags/InputElementFormattingTag.java index 7bb0c877c..f98c7cb3f 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/web/jsptags/InputElementFormattingTag.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/web/jsptags/InputElementFormattingTag.java @@ -385,10 +385,7 @@ public class InputElementFormattingTag extends TagSupport { public int doStartTag() { try { - /* first check for blank or missing type and id values */ - if (getType()==null || getType().equals("")){ - log.error("Error in doStartTag: input element type is blank or not specified."); - } + if (getId()==null || getId().equals("")){ log.error("Error in doStartTag: input element id is blank or not specified."); } @@ -440,6 +437,11 @@ public class InputElementFormattingTag extends TagSupport { // return SKIP_BODY; // } + + if ((getType()==null || getType().equals("")) && field.getEditElement() == null ){ + log.error("Error in doStartTag: input element type is blank or not specified."); + } + // set ProhibitedFromSearch object so picklist doesn't show // individuals from classes that should be hidden from list views OntModel displayOntModel = diff --git a/webapp/test/edu/cornell/mannlib/vitro/webapp/edit/elements/DateTimeWithPrecisionTest.java b/webapp/test/edu/cornell/mannlib/vitro/webapp/edit/elements/DateTimeWithPrecisionTest.java new file mode 100644 index 000000000..1f2c26b91 --- /dev/null +++ b/webapp/test/edu/cornell/mannlib/vitro/webapp/edit/elements/DateTimeWithPrecisionTest.java @@ -0,0 +1,218 @@ +/* $This file is distributed under the terms of the license in /doc/license.txt$ */ + +package edu.cornell.mannlib.vitro.webapp.edit.elements; + +import java.util.HashMap; +import java.util.Map; + +import org.joda.time.DateTime; +import org.junit.Assert; +import org.junit.Test; + +import com.hp.hpl.jena.datatypes.xsd.XSDDatatype; +import com.hp.hpl.jena.datatypes.xsd.XSDDateTime; +import com.hp.hpl.jena.rdf.model.Literal; + +import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary; +import edu.cornell.mannlib.vitro.webapp.edit.n3editing.EditConfiguration; +import edu.cornell.mannlib.vitro.webapp.edit.n3editing.Field; + + +public class DateTimeWithPrecisionTest { + + @Test + public void precisionSecondsValidationTest() throws Exception{ + String FIELDNAME = "testfield"; + Field field = new Field(); + field.setName(FIELDNAME); + DateTimeWithPrecision dtwp = new DateTimeWithPrecision(field); + + Map queryParameters = new HashMap(); + queryParameters.put(FIELDNAME+".year", new String[]{"1999" }); + queryParameters.put(FIELDNAME+".month", new String[]{"12"}); + queryParameters.put(FIELDNAME+".day", new String[]{"01"}); + queryParameters.put(FIELDNAME+".hour", new String[]{"12"}); + queryParameters.put(FIELDNAME+".minute", new String[]{"00"}); + queryParameters.put(FIELDNAME+".second", new String[]{"00"}); + EditConfiguration editConfig=null; + Map validationMsgs = dtwp.getValidationMessages("testfield", editConfig, queryParameters); + Assert.assertNotNull(validationMsgs); + Assert.assertTrue(validationMsgs.size() == 0 ); + + String precisionURI = null; + precisionURI = dtwp.getSubmittedPrecision( queryParameters); + + Assert.assertNotNull(precisionURI); + //Assert.assertEquals(dtwp.PRECISIONS[6], precisionURI); + Assert.assertEquals(VitroVocabulary.Precision.SECOND.uri(), precisionURI); + } + + @Test + public void precisionMinutesValidationTest() throws Exception{ + String FIELDNAME = "testfield"; + Field field = new Field(); + field.setName(FIELDNAME); + DateTimeWithPrecision dtwp = new DateTimeWithPrecision(field); + + Map queryParameters = new HashMap(); + queryParameters.put(FIELDNAME+".year", new String[]{"1999" }); + queryParameters.put(FIELDNAME+".month", new String[]{"12"}); + queryParameters.put(FIELDNAME+".day", new String[]{"01"}); + queryParameters.put(FIELDNAME+".hour", new String[]{"12"}); + queryParameters.put(FIELDNAME+".minute", new String[]{"00"}); + //no seconds + + EditConfiguration editConfig=null; + Map validationMsgs = dtwp.getValidationMessages("testfield", editConfig, queryParameters); + Assert.assertNotNull(validationMsgs); + Assert.assertTrue(validationMsgs.size() == 0 ); + + String precisionURI = null; + precisionURI = dtwp.getSubmittedPrecision( queryParameters); + + Assert.assertNotNull(precisionURI); + Assert.assertEquals(VitroVocabulary.Precision.MINUTE.uri(), precisionURI); + } + + @Test + public void precisionHourssValidationTest() throws Exception{ + String FIELDNAME = "testfield"; + Field field = new Field(); + field.setName(FIELDNAME); + DateTimeWithPrecision dtwp = new DateTimeWithPrecision(field); + + Map queryParameters = new HashMap(); + queryParameters.put(FIELDNAME+".year", new String[]{"1999" }); + queryParameters.put(FIELDNAME+".month", new String[]{"12"}); + queryParameters.put(FIELDNAME+".day", new String[]{"01"}); + queryParameters.put(FIELDNAME+".hour", new String[]{"12"}); + //no minutes + //no seconds + + EditConfiguration editConfig=null; + Map validationMsgs = dtwp.getValidationMessages("testfield", editConfig, queryParameters); + Assert.assertNotNull(validationMsgs); + Assert.assertTrue(validationMsgs.size() == 0 ); + + String precisionURI = null; + precisionURI = dtwp.getSubmittedPrecision( queryParameters); + + Assert.assertNotNull(precisionURI); + Assert.assertEquals(VitroVocabulary.Precision.HOUR.uri(), precisionURI); + } + + @Test + public void precisionDaysValidationTest() throws Exception{ + String FIELDNAME = "testfield"; + Field field = new Field(); + field.setName(FIELDNAME); + DateTimeWithPrecision dtwp = new DateTimeWithPrecision(field); + + Map queryParameters = new HashMap(); + queryParameters.put(FIELDNAME+".year", new String[]{"1999" }); + queryParameters.put(FIELDNAME+".month", new String[]{"12"}); + queryParameters.put(FIELDNAME+".day", new String[]{"01"}); + //no hours + //no minutes + //no seconds + + EditConfiguration editConfig=null; + Map validationMsgs = dtwp.getValidationMessages("testfield", editConfig, queryParameters); + Assert.assertNotNull(validationMsgs); + Assert.assertTrue(validationMsgs.size() == 0 ); + + String precisionURI = null; + precisionURI = dtwp.getSubmittedPrecision( queryParameters); + + Assert.assertNotNull(precisionURI); + Assert.assertEquals(VitroVocabulary.Precision.DAY.uri(), precisionURI); + } + + @Test + public void precisionMonthsValidationTest()throws Exception{ + String FIELDNAME = "testfield"; + Field field = new Field(); + field.setName(FIELDNAME); + DateTimeWithPrecision dtwp = new DateTimeWithPrecision(field); + + Map queryParameters = new HashMap(); + queryParameters.put(FIELDNAME+".year", new String[]{"1999" }); + queryParameters.put(FIELDNAME+".month", new String[]{"12"}); + //no days + //no hours + //no minutes + //no seconds + + EditConfiguration editConfig=null; + Map validationMsgs = dtwp.getValidationMessages("testfield", editConfig, queryParameters); + Assert.assertNotNull(validationMsgs); + Assert.assertTrue(validationMsgs.size() == 0 ); + + String precisionURI = null; + precisionURI = dtwp.getSubmittedPrecision( queryParameters); + + Assert.assertNotNull(precisionURI); + Assert.assertEquals(VitroVocabulary.Precision.MONTH.uri(), precisionURI); + } + + @Test + public void precisionYearValidationTest() throws Exception{ + String FIELDNAME = "testfield"; + Field field = new Field(); + field.setName(FIELDNAME); + DateTimeWithPrecision dtwp = new DateTimeWithPrecision(field); + + Map queryParameters = new HashMap(); + queryParameters.put(FIELDNAME+".year", new String[]{"1999" }); + //no months + //no days + //no hours + //no minutes + //no seconds + + EditConfiguration editConfig=null; + Map validationMsgs = dtwp.getValidationMessages("testfield", editConfig, queryParameters); + Assert.assertNotNull(validationMsgs); + Assert.assertTrue(validationMsgs.size() == 0 ); + + String precisionURI = null; + precisionURI = dtwp.getSubmittedPrecision( queryParameters); + + Assert.assertNotNull(precisionURI); + Assert.assertEquals(VitroVocabulary.Precision.YEAR.uri(), precisionURI); + } + + @Test + public void getDateLiteralTest(){ + String FIELDNAME = "testfield"; + Field field = new Field(); + field.setName(FIELDNAME); + DateTimeWithPrecision dtwp = new DateTimeWithPrecision(field); + + Map queryParameters = new HashMap(); + queryParameters.put(FIELDNAME+".year", new String[]{"1999" }); + //no months + //no days + //no hours + //no minutes + //no seconds + + EditConfiguration editConfig=null; + Map validationMsgs = dtwp.getValidationMessages("testfield", editConfig, queryParameters); + Assert.assertNotNull(validationMsgs); + Assert.assertTrue(validationMsgs.size() == 0 ); + + Literal date = dtwp.getDateTime( queryParameters); + Assert.assertNotNull(date); + Assert.assertEquals( XSDDatatype.XSDdateTime.getURI() ,date.getDatatypeURI() ); + + DateTime result = new DateTime( date.getLexicalForm() ); + DateTime expected = new DateTime(1999,1,1,0,0,0,0); + Assert.assertEquals(expected, result); + + Object obj = date.getValue(); + Assert.assertNotNull(obj); + Assert.assertEquals(XSDDateTime.class, obj.getClass()); + } + +} diff --git a/webapp/web/edit/forms/test/dateTimePrecTest.jsp b/webapp/web/edit/forms/test/dateTimePrecTest.jsp index 4541dd67b..16c00afa5 100644 --- a/webapp/web/edit/forms/test/dateTimePrecTest.jsp +++ b/webapp/web/edit/forms/test/dateTimePrecTest.jsp @@ -29,6 +29,34 @@ This is a test file for the DateTimeWithPrecision EditElement. WebappDaoFactory wdf = vreq.getWebappDaoFactory(); %> + + PREFIX owl: + SELECT ?inverse_property + WHERE { + ?inverse_property owl:inverseOf ?predicate + } + + + + PREFIX rdf: + PREFIX core: + SELECT ?dtX.precision WHERE { + ?subject ?predicate ?object . + ?object ?dtX. + ?dtX . + ?dtX ?dtX.precision . + + + + PREFIX rdf: + PREFIX core: + SELECT ?dtX.value WHERE { + ?subject ?predicate ?object . + ?object ?dtX. + ?dtX . + ?dtX ?dtX.value . + + @prefix rdf: . @prefix rdfs: . @@ -64,13 +92,14 @@ This is a test file for the DateTimeWithPrecision EditElement. "filesOnForm" : [ ], "sparqlForLiterals" : { }, "sparqlForUris" : { }, - "sparqlForExistingLiterals" : { }, - "sparqlForExistingUris" : { }, + "sparqlForExistingLiterals" : { "dtX.value": "${sparqlForDxValue}" }, + "sparqlForExistingUris" : { "dtX.precision": "${sparqlForDxPrecision}" }, "fields" : { "dtX" : { "newResource" : "true", "validators" : [ ], "optionsType" : "edu.cornell.mannlib.vitro.webapp.edit.elements.DateTimeWithPrecision", + "editElement" : "edu.cornell.mannlib.vitro.webapp.edit.elements.DateTimeWithPrecision", "literalOptions" : [ ], "predicateUri" : "", "objectClassUri" : "", @@ -107,7 +136,7 @@ This is a test file for the DateTimeWithPrecision EditElement.

${title}

" > - +