updates for concept addition and integration of umls/agrovoc search services

productMods/edit/forms/js/addConcept.js

@@ -120,7 +120,8 @@ var addConceptForm = {
     submitSearchTerm: function() {
     	//Get value of search term
     	var searchValue = this.searchTerm.val();
-    	var dataServiceUrl = addConceptForm.dataServiceUrl + "?searchTerm=" + encodeURIComponent(searchValue);
+    	var vocabSourceValue = this.vocabSource.val();
+    	var dataServiceUrl = addConceptForm.dataServiceUrl + "?searchTerm=" + encodeURIComponent(searchValue) + "&source=" + encodeURIComponent(vocabSourceValue);
         $.getJSON(dataServiceUrl, function(results) {
             if ( results.array.length == 0 ) {
             	alert("results not correct length");

productMods/templates/freemarker/edit/forms/addAssociatedConcept.ftl

@@ -11,7 +11,7 @@
 
 
 <#--This is set for testing purposes - will be retrieved dynamically from the generator later-->
-<#assign sources = [{"uri":"http://link.informatics.stonybrook.edu/umls/", "label":"UMLS"}, {"uri":"http://www.agrovoc.com", "label":"Agrovoc"}]/>
+<#assign sources = [{"uri":"http://link.informatics.stonybrook.edu/umls/", "label":"UMLS"}, {"uri":"http://www.fao.org/webservices/Agrovoc", "label":"Agrovoc"}]/>
 <#assign selectedSource = "UMLS" />
 
 <h2>Manage Concepts</h2>
@@ -117,7 +117,7 @@
 
     <script type="text/javascript">
     var customFormData = {
-        dataServiceUrl: '${urls.base}/UMLSTermsRetrieval',
+        dataServiceUrl: '${urls.base}/conceptSearchService',
         UMLSCUIURL: 'http://link.informatics.stonybrook.edu/umls/CUI/'
     };
     </script>

src/edu/cornell/mannlib/semservices/bo/Concept.java

@@ -0,0 +1,104 @@
+package edu.cornell.mannlib.semservices.bo;
+
+public class Concept {
+
+   private String definedBy;
+   private String conceptId;
+   private String bestMatch;
+   private String label;
+   private String type;
+   private String definition;
+   private String uri;
+
+   /**
+    * default constructor
+    */
+   public Concept() {
+
+   }
+   /**
+    * @return the conceptId
+    */
+   public String getConceptId() {
+      return conceptId;
+   }
+   /**
+    * @param conceptId the conceptId to set
+    */
+   public void setConceptId(String conceptId) {
+      this.conceptId = conceptId;
+   }
+   /**
+    * @return the label
+    */
+   public String getLabel() {
+      return label;
+   }
+   /**
+    * @param label the label to set
+    */
+   public void setLabel(String label) {
+      this.label = label;
+   }
+   /**
+    * @return the type
+    */
+   public String getType() {
+      return type;
+   }
+   /**
+    * @param type the type to set
+    */
+   public void setType(String type) {
+      this.type = type;
+   }
+   /**
+    * @return the definition
+    */
+   public String getDefinition() {
+      return definition;
+   }
+   /**
+    * @param definition the definition to set
+    */
+   public void setDefinition(String definition) {
+      this.definition = definition;
+   }
+   /**
+    * @return the uri
+    */
+   public String getUri() {
+      return uri;
+   }
+   /**
+    * @param uri the uri to set
+    */
+   public void setUri(String uri) {
+      this.uri = uri;
+   }
+   /**
+    * @return the definedBy
+    */
+   public String getDefinedBy() {
+      return definedBy;
+   }
+   /**
+    * @param definedBy the definedBy to set
+    */
+   public void setDefinedBy(String definedBy) {
+      this.definedBy = definedBy;
+   }
+   /**
+    * @return the bestMatch
+    */
+   public String getBestMatch() {
+      return bestMatch;
+   }
+   /**
+    * @param bestMatch the bestMatch to set
+    */
+   public void setBestMatch(String bestMatch) {
+      this.bestMatch = bestMatch;
+   }
+
+}

src/edu/cornell/mannlib/semservices/bo/Day.java

@@ -0,0 +1,749 @@
+package edu.cornell.mannlib.semservices.bo;
+
+import java.util.Calendar;
+import java.util.Date;
+import java.util.TimeZone;
+
+import edu.cornell.mannlib.semservices.util.DateUtils;
+
+/**
+ * A time-less and immutable Date class for basic date arithmetics.
+ *
+ * @author <a href="mailto:jacob.dreyer@geosoft.no">Jacob Dreyer</a>
+ */
+public class Day implements Comparable<Day> {
+   /** The back end calendar instance of this day. */
+   protected  Calendar calendar_ = Calendar.getInstance();
+
+   /**
+    * Create a new day. The day is lenient meaning that illegal day parameters
+    * can be specified and results in a recomputed day with legal month/day
+    * values.
+    *
+    * @param year
+    *           Year of new day.
+    * @param month
+    *           Month of new day (0-11)
+    * @param dayOfMonth
+    *           Day of month of new day (1-31)
+    */
+   public Day(int year, int month, int dayOfMonth) {
+      initialize(year, month, dayOfMonth);
+   }
+
+   /**
+    * Create a new day, specifying the year and the day of year. The day is
+    * lenient meaning that illegal day parameters can be specified and results
+    * in a recomputed day with legal month/day values.
+    *
+    * @param year
+    *           Year of new day.
+    * @param dayOfYear
+    *           1=January 1, etc.
+    */
+   public Day(int year, int dayOfYear) {
+      initialize(year, Calendar.JANUARY, 1);
+      calendar_.set(Calendar.DAY_OF_YEAR, dayOfYear);
+   }
+
+   /**
+    * Create a new day representing the day of creation (according to the
+    * setting of the current machine).
+    */
+   public Day() {
+      // Now (in the current locale of the client machine)
+      Calendar calendar = Calendar.getInstance();
+
+      // Prune time part
+      initialize(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH),
+            calendar.get(Calendar.DAY_OF_MONTH));
+   }
+
+   /**
+    * Create a new day based on a java.util.Calendar instance. NOTE: The time
+    * component from calendar will be pruned.
+    *
+    * @param calendar
+    *           Calendar instance to copy.
+    * @throws IllegalArgumentException
+    *            If calendar is null.
+    */
+   public Day(Calendar calendar) {
+      if (calendar == null)
+         throw new IllegalArgumentException("calendar cannot be null");
+
+      initialize(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH),
+            calendar.get(Calendar.DAY_OF_MONTH));
+   }
+
+   /**
+    * Create a new day based on a java.util.Date instance. NOTE: The time
+    * component from date will be pruned.
+    *
+    * @param date
+    *           Date instance to copy.
+    * @throws IllegalArgumentException
+    *            If date is null.
+    */
+   public Day(Date date) {
+      if (date == null)
+         throw new IllegalArgumentException("date cannot be null");
+
+      // Create a calendar based on given date
+      Calendar calendar = Calendar.getInstance();
+      calendar.setTime(date);
+
+      // Extract date values and use these only
+      initialize(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH),
+            calendar.get(Calendar.DAY_OF_MONTH));
+   }
+
+   /**
+    * Create a new day based on a time value. Time is milliseconds since
+    * "the Epoch" (1.1.1970). NOTE: The time component from time will be pruned.
+    *
+    * @param time
+    *           Milliseconds since "the Epoch".
+    */
+   public Day(long time) {
+      this(new Date(time));
+   }
+
+   /**
+    * Create a new day as a copy of the specified day.
+    *
+    * @param day
+    *           Day to clone.
+    * @throws IllegalArgumentException
+    *            If day is null.
+    */
+   public Day(Day day) {
+      if (day == null)
+         throw new IllegalArgumentException("day cannot be null");
+
+      initialize(day.getYear(), day.getMonth(), day.getDayOfMonth());
+   }
+
+   /**
+    * Initialize the internal calendar instance.
+    *
+    * @param year
+    *           Year of new day.
+    * @param month
+    *           Month of new day.
+    * @param dayOfMonth
+    *           Day of month of new day.
+    */
+   private void initialize(int year, int month, int dayOfMonth) {
+      calendar_.setLenient(true);
+      calendar_.setFirstDayOfWeek(Calendar.MONDAY);
+      calendar_.setTimeZone(TimeZone.getDefault());
+      calendar_.set(Calendar.YEAR, year);
+      calendar_.set(Calendar.MONTH, month);
+      calendar_.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+
+      // Prune the time component
+      calendar_.set(Calendar.HOUR_OF_DAY, 0);
+      calendar_.set(Calendar.MINUTE, 0);
+      calendar_.set(Calendar.SECOND, 0);
+      calendar_.set(Calendar.MILLISECOND, 0);
+   }
+
+   /**
+    * A more explicit front-end to the Day() constructor which return a day
+    * object representing the day of creation.
+    *
+    * @return A day instance representing today.
+    */
+   public static Day today() {
+      return new Day();
+   }
+
+   /**
+    * Return a Calendar instance representing the same day as this instance. For
+    * use by secondary methods requiring java.util.Calendar as input.
+    *
+    * @return Calendar equivalent representing this day.
+    */
+   public Calendar getCalendar() {
+      return (Calendar) calendar_.clone();
+   }
+
+   /**
+    * Return a Date instance representing the same date as this instance. For
+    * use by secondary methods requiring java.util.Date as input.
+    *
+    * @return Date equivalent representing this day.
+    */
+   public Date getDate() {
+      return getCalendar().getTime();
+   }
+
+   /**
+    * Compare this day to the specified day. If object is not of type Day a
+    * ClassCastException is thrown.
+    *
+    * @param day
+    *           Day object to compare to.
+    * @return @see Comparable#compareTo(Object)
+    * @throws IllegalArgumentException
+    *            If day is null.
+    */
+   public int compareTo(Day day) {
+      if (day == null)
+         throw new IllegalArgumentException("day cannot be null");
+
+      return calendar_.getTime().compareTo(day.calendar_.getTime());
+   }
+
+   /**
+    * Return true if this day is after the specified day.
+    *
+    * @param day
+    *           Day to compare to.
+    * @return True if this is after day, false otherwise.
+    * @throws IllegalArgumentException
+    *            If day is null.
+    */
+   public boolean isAfter(Day day) {
+      if (day == null)
+         throw new IllegalArgumentException("day cannot be null");
+
+      return calendar_.after(day.calendar_);
+   }
+
+   /**
+    * Return true if this day is before the specified day.
+    *
+    * @param day
+    *           Day to compare to.
+    * @return True if this is before day, false otherwise.
+    * @throws IllegalArgumentException
+    *            If day is null.
+    */
+   public boolean isBefore(Day day) {
+      if (day == null)
+         throw new IllegalArgumentException("day cannot be null");
+
+      return calendar_.before(day.calendar_);
+   }
+
+   /**
+    * Return true if this day equals (represent the same date) as the specified
+    * day.
+    *
+    * @param object
+    *           Object to compare to.
+    * @return True if this equals day, false otherwise.
+    * @throws IllegalArgumentException
+    *            If day is null.
+    */
+   @Override
+   public boolean equals(Object object) {
+      Day day = (Day) object;
+
+      if (day == null)
+         throw new IllegalArgumentException("day cannot be null");
+
+      return calendar_.equals(day.calendar_);
+   }
+
+   /**
+    * Overload required as default definition of equals() has changed.
+    *
+    * @return A hash code value for this object.
+    */
+   @Override
+   public int hashCode() {
+      return calendar_.hashCode();
+   }
+
+   /**
+    * Return year of this day.
+    *
+    * @return Year of this day.
+    */
+   public int getYear() {
+      return calendar_.get(Calendar.YEAR);
+   }
+
+
+
+   /**
+    * Return month of this day. The result must be compared to Calendar.JANUARY,
+    * Calendar.FEBRUARY, etc.
+    *
+    * @return Month of this day.
+    */
+   public int getMonth() {
+      return calendar_.get(Calendar.MONTH);
+   }
+
+   public String getMonthName() {
+      switch (getMonth()) {
+      case Calendar.JANUARY:
+         return "January";
+      case Calendar.FEBRUARY:
+         return "February";
+      case Calendar.MARCH:
+         return "March";
+      case Calendar.APRIL:
+         return "April";
+      case Calendar.MAY:
+         return "May";
+      case Calendar.JUNE:
+         return "June";
+      case Calendar.JULY:
+         return "July";
+      case Calendar.AUGUST:
+         return "August";
+      case Calendar.SEPTEMBER:
+         return "September";
+      case Calendar.OCTOBER:
+         return "October";
+      case Calendar.NOVEMBER:
+         return "November";
+      case Calendar.DECEMBER:
+         return "December";
+      default:
+         assert false : "Invalid mongth: " + getMonth();
+      }
+
+      // This will never happen
+      return "";
+   }
+
+   /**
+    * Return the 1-based month number of the month of this day. 1 = January, 2 =
+    * February and so on.
+    *
+    * @return Month number of this month
+    */
+   public int getMonthNo() {
+      // It is tempting to return getMonth() + 1 but this is conceptually
+      // wrong, as Calendar month is an enumeration and the values are tags
+      // only and can be anything.
+      switch (getMonth()) {
+      case Calendar.JANUARY:
+         return 1;
+      case Calendar.FEBRUARY:
+         return 2;
+      case Calendar.MARCH:
+         return 3;
+      case Calendar.APRIL:
+         return 4;
+      case Calendar.MAY:
+         return 5;
+      case Calendar.JUNE:
+         return 6;
+      case Calendar.JULY:
+         return 7;
+      case Calendar.AUGUST:
+         return 8;
+      case Calendar.SEPTEMBER:
+         return 9;
+      case Calendar.OCTOBER:
+         return 10;
+      case Calendar.NOVEMBER:
+         return 11;
+      case Calendar.DECEMBER:
+         return 12;
+      default:
+         assert false : "Invalid mongth: " + getMonth();
+      }
+
+      // This will never happen
+      return 0;
+   }
+
+   /**
+    * Return day of month of this day. NOTE: First day of month is 1 (not 0).
+    *
+    * @return Day of month of this day.
+    */
+   public int getDayOfMonth() {
+      return calendar_.get(Calendar.DAY_OF_MONTH);
+   }
+
+   /**
+    * Return the day number of year this day represents. January 1 = 1 and so
+    * on.
+    *
+    * @return day number of year.
+    */
+   public int getDayOfYear() {
+      return calendar_.get(Calendar.DAY_OF_YEAR);
+   }
+
+   /**
+    * Return the day of week of this day. NOTE: Must be compared to
+    * Calendar.MONDAY, TUSEDAY etc.
+    *
+    * @return Day of week of this day.
+    */
+   public int getDayOfWeek() {
+      return calendar_.get(Calendar.DAY_OF_WEEK);
+   }
+
+   /**
+    * Return the day number of week of this day, where Monday=1, Tuesday=2, ...
+    * Sunday=7.
+    *
+    * @return Day number of week of this day.
+    */
+   public int getDayNumberOfWeek() {
+      return getDayOfWeek() == Calendar.SUNDAY ? 7 : getDayOfWeek()
+            - Calendar.SUNDAY;
+   }
+
+   /**
+    * Return the week number of year, this day belongs to. 1st=1 and so on.
+    *
+    * @return Week number of year of this day.
+    */
+   public int getWeekOfYear() {
+      return calendar_.get(Calendar.WEEK_OF_YEAR);
+   }
+
+   /**
+    * Return a day which is the given number of days after this day.
+    *
+    * @param nDays
+    *           Number of days to add. May be negative.
+    * @return Day as requested.
+    */
+   public Day addDays(int nDays) {
+      // Create a clone
+      Calendar calendar = (Calendar) calendar_.clone();
+
+      // Add/remove the specified number of days
+      calendar.add(Calendar.DAY_OF_MONTH, nDays);
+
+      // Return new instance
+      return new Day(calendar);
+   }
+
+   /**
+    * Subtract a number of days from this day.
+    *
+    * @param nDays
+    *           Number of days to subtract.
+    * @return Day as requested.
+    */
+   public Day subtractDays(int nDays) {
+      return addDays(-nDays);
+   }
+
+   /**
+    * Return a day wich is a given number of month after this day.
+    *
+    * The actual number of days added depends on the staring day. Subtracting a
+    * number of months can be done by a negative argument to addMonths() or
+    * calling subtactMonths() explicitly. NOTE: addMonth(n) m times will in
+    * general give a different result than addMonth(m*n). Add 1 month to January
+    * 31, 2005 will give February 28, 2005.
+    *
+    * @param nMonths
+    *           Number of months to add.
+    * @return Day as requested.
+    */
+   public Day addMonths(int nMonths) {
+      // Create a clone
+      Calendar calendar = (Calendar) calendar_.clone();
+
+      // Add/remove the specified number of days
+      calendar.add(Calendar.MONTH, nMonths);
+
+      // Return new instance
+      return new Day(calendar);
+   }
+
+   /**
+    * Subtract a number of months from this day.
+    *
+    * @see #addMonths(int).
+    *
+    * @param nMonths
+    *           Number of months to subtract.
+    * @return Day as requested.
+    */
+   public Day subtractMonths(int nMonths) {
+      return addMonths(-nMonths);
+   }
+
+   /**
+    * Return a day wich is a given number of years after this day.
+    *
+    * Add a number of years to this day. The actual number of days added depends
+    * on the starting day. Subtracting a number of years can be done by a
+    * negative argument to addYears() or calling subtractYears explicitly.
+    *
+    * @param nYears
+    *           Number of years to add.
+    * @return Day as requested.
+    */
+   public Day addYears(int nYears) {
+      // Create a clone
+      Calendar calendar = (Calendar) calendar_.clone();
+
+      // Add/remove the specified number of days
+      calendar.add(Calendar.YEAR, nYears);
+
+      // Return new instance
+      return new Day(calendar);
+   }
+
+   /**
+    * Subtract a number of years from this day.
+    *
+    * @see #addYears(int).
+    *
+    * @param nYears
+    *           Number of years to subtract.
+    * @return Day as requested.
+    */
+   public Day subtractYears(int nYears) {
+      return addYears(-nYears);
+   }
+
+   /**
+    * Return the number of days in the year of this day.
+    *
+    * @return Number of days in this year.
+    */
+   public int getDaysInYear() {
+      return calendar_.getActualMaximum(Calendar.DAY_OF_YEAR);
+   }
+
+   /**
+    * Return true if the year of this day is a leap year.
+    *
+    * @return True if this year is a leap year, false otherwise.
+    */
+   public boolean isLeapYear() {
+      return getDaysInYear() == calendar_.getMaximum(Calendar.DAY_OF_YEAR);
+   }
+
+   /**
+    * Return true if the specified year is a leap year.
+    *
+    * @param year
+    *           Year to check.
+    * @return True if specified year is leap year, false otherwise.
+    */
+   public static boolean isLeapYear(int year) {
+      return (new Day(year, Calendar.JANUARY, 1)).isLeapYear();
+   }
+
+   /**
+    * Return the number of days in the month of this day.
+    *
+    * @return Number of days in this month.
+    */
+   public int getDaysInMonth() {
+      return calendar_.getActualMaximum(Calendar.DAY_OF_MONTH);
+   }
+
+
+
+   /**
+    * Get default locale name of this day ("Monday", "Tuesday", etc.
+    *
+    * @return Name of day.
+    */
+   public String getDayName() {
+      switch (getDayOfWeek()) {
+      case Calendar.MONDAY:
+         return "Monday";
+      case Calendar.TUESDAY:
+         return "Tuesday";
+      case Calendar.WEDNESDAY:
+         return "Wednesday";
+      case Calendar.THURSDAY:
+         return "Thursday";
+      case Calendar.FRIDAY:
+         return "Friday";
+      case Calendar.SATURDAY:
+         return "Saturday";
+      case Calendar.SUNDAY:
+         return "Sunday";
+      default:
+         assert false : "Invalid day of week: " + getDayOfWeek();
+      }
+
+      // This will never happen
+      return null;
+   }
+
+   /**
+    * Get default locale name of this day ("Monday", "Tuesday", etc.
+    *
+    * @return Name of day.
+    */
+   public String getShortDayName() {
+      switch (getDayOfWeek()) {
+      case Calendar.MONDAY:
+         return "Mon";
+      case Calendar.TUESDAY:
+         return "Tue";
+      case Calendar.WEDNESDAY:
+         return "Wed";
+      case Calendar.THURSDAY:
+         return "Thu";
+      case Calendar.FRIDAY:
+         return "Fri";
+      case Calendar.SATURDAY:
+         return "Sat";
+      case Calendar.SUNDAY:
+         return "Sun";
+      default:
+         assert false : "Invalid day of week: " + getDayOfWeek();
+      }
+
+      // This will never happen
+      return null;
+   }
+
+   /**
+    * Return number of days between two days. The method always returns a
+    * positive number of days.
+    *
+    * @param day
+    *           The day to compare to.
+    * @return Number of days between this and day.
+    * @throws IllegalArgumentException
+    *            If day is null.
+    */
+   public int daysBetween(Day day) {
+      if (day == null)
+         throw new IllegalArgumentException("day cannot be null");
+
+      long millisBetween = Math.abs(calendar_.getTime().getTime()
+            - day.calendar_.getTime().getTime());
+      return (int) Math.round(millisBetween / (1000 * 60 * 60 * 24));
+   }
+
+   /**
+    * Find the n'th xxxxday of s specified month (for instance find 1st sunday
+    * of May 2006; findNthOfMonth (1, Calendar.SUNDAY, Calendar.MAY, 2006);
+    * Return null if the specified day doesn't exists.
+    *
+    * @param n
+    *           Nth day to look for.
+    * @param dayOfWeek
+    *           Day to look for (Calendar.XXXDAY).
+    * @param month
+    *           Month to check (Calendar.XXX).
+    * @param year
+    *           Year to check.
+    * @return Required Day (or null if non-existent)
+    * @throws IllegalArgumentException
+    *            if dyaOfWeek parameter doesn't represent a valid day.
+    */
+   public static Day getNthOfMonth(int n, int dayOfWeek, int month, int year) {
+      // Validate the dayOfWeek argument
+
+      if (dayOfWeek < 1 || dayOfWeek > 7)
+         throw new IllegalArgumentException("Invalid day of week: " + dayOfWeek);
+
+      Day first = new Day(year, month, 1);
+
+      int offset = dayOfWeek - first.getDayOfWeek();
+      if (offset < 0)
+         offset = 7 + offset;
+
+      int dayNo = (n - 1) * 7 + offset + 1;
+
+      return dayNo > first.getDaysInMonth() ? null
+            : new Day(year, month, dayNo);
+   }
+
+   /**
+    * Find the first of a specific day in a given month. For instance first
+    * Tuesday of May: getFirstOfMonth(Calendar.TUESDAY, Calendar.MAY, 2005);
+    *
+    * @param dayOfWeek
+    *           Weekday to get.
+    * @param month
+    *           Month of day to get.
+    * @param year
+    *           Year of day to get.
+    * @return The requested day.
+    */
+   public static Day getFirstOfMonth(int dayOfWeek, int month, int year) {
+      return Day.getNthOfMonth(1, dayOfWeek, month, year);
+   }
+
+   /**
+    * Find the last of a specific day in a given month. For instance last
+    * Tuesday of May: getLastOfMonth (Calendar.TUESDAY, Calendar.MAY, 2005);
+    *
+    * @param dayOfWeek
+    *           Weekday to get.
+    * @param month
+    *           Month of day to get.
+    * @param year
+    *           Year of day to get.
+    * @return The requested day.
+    */
+   public static Day getLastOfMonth(int dayOfWeek, int month, int year) {
+      Day day = Day.getNthOfMonth(5, dayOfWeek, month, year);
+      return day != null ? day : Day.getNthOfMonth(4, dayOfWeek, month, year);
+   }
+
+   public String getFormattedString(String fmt) {
+      return DateUtils.getFormattedDate(calendar_.getTime(), fmt);
+   }
+
+   /**
+    * Return a scratch string representation of this day. Used for debugging
+    * only. The format of the day is yyyy-mm-dd
+    *
+    * @return A string representation of this day.
+    */
+   @Override
+   public String toString() {
+      StringBuffer s = new StringBuffer();
+      s.append(getYear());
+      s.append('-');
+      if (getMonth() < 9)
+         s.append('0');
+      s.append(getMonth() + 1);
+      s.append('-');
+      if (getDayOfMonth() < 10)
+         s.append('0');
+      s.append(getDayOfMonth());
+      return s.toString();
+   }
+
+   /**
+    * Testing this class.
+    *
+    * @param arguments
+    *           Not used.
+    */
+   public static void main(String[] arguments) {
+      // This proves that there are 912 days between the two major
+      // terrorist attacks, not 911 as is common knowledge.
+      Day september11 = new Day(2001, Calendar.SEPTEMBER, 11);
+      Day march11 = new Day(2004, Calendar.MARCH, 11);
+      System.out.println(september11.daysBetween(march11));
+
+      // This proves that Kennedy was president for 1037 days,
+      // not 1000 as is the popular belief nor 1036 which is the
+      // bluffers reply. Nerds knows when to add one...
+      Day precidency = new Day(1961, Calendar.JANUARY, 20);
+      Day assasination = new Day(1963, Calendar.NOVEMBER, 22);
+      System.out.println(precidency.daysBetween(assasination) + 1);
+
+      // Niel Armstrong walked the moon on a Sunday
+      Day nielOnMoon = new Day(1969, Calendar.JULY, 20);
+      System.out.println("Niel Armstron walked on the moon on "+ nielOnMoon.getDayName());
+
+      // Find last tuesdays for 2005
+      for (int i = 0; i < 12; i++) {
+         Day tuesday = Day.getLastOfMonth(Calendar.TUESDAY, i, 2005);
+         System.out.println(tuesday);
+      }
+   }
+}

src/edu/cornell/mannlib/semservices/bo/Time.java

@@ -0,0 +1,257 @@
+package edu.cornell.mannlib.semservices.bo;
+
+import java.util.Date;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * A class representing a moment in time. Extends Day which represents the day
+ * of the moment, and defines the time within the day to millisecond accuracy.
+ *
+ * @author Jacob Dreyer (<a
+ *         href="mailto:jacob.dreyer@geosoft.no">jacob.dreyer@geosoft.no</a>)
+ */
+public class Time extends Day {
+   protected final Log logger = LogFactory.getLog(getClass());
+
+   protected static final Log staticlogger = LogFactory.getLog(Time.class);
+
+   /**
+    * Instantiate a Time object. The time is lenient meaning that illegal day
+    * parameters can be specified and results in a recomputed day with legal
+    * month/day values.
+    *
+    * @param year  Year of this time
+    * @param month Month of this time
+    * @param dayOfMonth Day of month of this time.
+    * @param hourOfDay Hours of this time [0-23]
+    * @param minutes Minutes of this time [0-23]
+    * @param seconds Seconds of this time [0-23]
+    */
+   public Time(int year, int month, int dayOfMonth, int hourOfDay, int minutes,
+         int seconds) {
+      super(year, month, dayOfMonth);
+      setHourOfDay(hourOfDay);
+      setMinutes(minutes);
+      setSeconds(seconds);
+   }
+
+   /**
+    * Constructor
+    * @param day
+    * @param hourOfDay
+    * @param minutes
+    * @param seconds
+    */
+   public Time(Day day, int hourOfDay, int minutes, int seconds) {
+      this(day.getYear(), day.getMonth(), day.getDayOfMonth(), hourOfDay,
+            minutes, seconds);
+   }
+
+
+   /**
+    * Constructor
+    * @param hourOfDay
+    * @param minutes
+    * @param seconds
+    */
+   public Time(int hourOfDay, int minutes, int seconds) {
+      this(new Day(), hourOfDay, minutes, seconds);
+   }
+
+   /**
+    * Constructor
+    */
+   public Time() {
+      calendar_ = new GregorianCalendar(); // Now
+   }
+
+   // end of constructors
+
+   // Get Methods
+
+   public Date getDay() {
+      return calendar_.getTime();
+   }
+
+   public int getHour() {
+      return calendar_.get(Calendar.HOUR);
+   }
+
+   public int getHourOfDay() {
+      return calendar_.get(Calendar.HOUR_OF_DAY);
+   }
+
+   public int getMinutes() {
+      return calendar_.get(Calendar.MINUTE);
+   }
+
+   public int getSeconds() {
+      return calendar_.get(Calendar.SECOND);
+   }
+
+   public int getMilliSeconds() {
+      return calendar_.get(Calendar.MILLISECOND);
+   }
+
+   public int getAmPm() {
+      return calendar_.get(Calendar.AM_PM);
+   }
+
+   // set Methods
+
+   public void setDay(Day day) {
+      setYear(day.getYear());
+      setMonth(day.getMonth());
+      setDayOfMonth(day.getDayOfMonth());
+   }
+
+   public void setYear(int year) {
+      calendar_.set(Calendar.YEAR, year);
+   }
+
+   public void setMonth(int month) {
+      calendar_.set(Calendar.MONTH, month);
+   }
+
+   public void setDayOfMonth(int dayOfMonth) {
+      calendar_.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+   }
+
+   public void setHourOfDay(int hourOfDay) {
+      calendar_.set(Calendar.HOUR_OF_DAY, hourOfDay);
+   }
+
+   public void setHour(int hour) {
+      calendar_.set(Calendar.HOUR, hour);
+   }
+
+   public void setAmPm(int amPm) {
+      calendar_.set(Calendar.AM_PM, amPm);
+   }
+
+   public void setMinutes(int minutes) {
+      calendar_.set(Calendar.MINUTE, minutes);
+   }
+
+   public void setSeconds(int seconds) {
+      calendar_.set(Calendar.SECOND, seconds);
+   }
+
+   public void setMilliSeconds(int milliSeconds) {
+      calendar_.set(Calendar.MILLISECOND, milliSeconds);
+   }
+
+   // Time modification methods
+
+   public void addHours(int nHours) {
+      calendar_.add(Calendar.HOUR_OF_DAY, nHours);
+   }
+
+   public void addMinutes(int nMinutes) {
+      calendar_.add(Calendar.MINUTE, nMinutes);
+   }
+
+   public void addSeconds(int nSeconds) {
+      calendar_.add(Calendar.SECOND, nSeconds);
+   }
+
+   public void addMilliSeconds(int nMilliSeconds) {
+      calendar_.add(Calendar.MILLISECOND, nMilliSeconds);
+   }
+
+   public void subtractHours(int nHours) {
+      addHours(-nHours);
+   }
+
+   public void subtractMinutes(int nMinutes) {
+      addMinutes(-nMinutes);
+   }
+
+   public void subtractSeconds(int nSeconds) {
+      addSeconds(-nSeconds);
+   }
+
+   // Time test methods
+
+   public boolean isAfter(Time time) {
+      return calendar_.after(time.calendar_);
+   }
+
+   public boolean isBefore(Time time) {
+      return calendar_.before(time.calendar_);
+   }
+
+   public boolean equals(Time time) {
+      return calendar_.equals(time.calendar_);
+   }
+
+   // Time difference methods
+
+   public long milliSecondsBetween(Time time) {
+      long millisBetween = calendar_.getTime().getTime()
+            - time.calendar_.getTime().getTime();
+      return millisBetween;
+   }
+
+   public double secondsBetween(Time time) {
+      long millisBetween = calendar_.getTime().getTime()
+            - time.calendar_.getTime().getTime();
+      return millisBetween / 1000;
+   }
+
+   public double minutesBetween(Time time) {
+      long millisBetween = calendar_.getTime().getTime()
+            - time.calendar_.getTime().getTime();
+      return millisBetween / (1000 * 60);
+   }
+
+   public double hoursBetween(Time time) {
+      long millisBetween = calendar_.getTime().getTime()
+            - time.calendar_.getTime().getTime();
+      return millisBetween / (1000 * 60 * 60);
+   }
+
+   // Display methods
+
+   public String toString() {
+      StringBuffer string = new StringBuffer();
+
+      if (getHour() == 0) {
+         string.append("12"); // display "12" for midnight
+      } else {
+         string.append(getHour());
+      }
+      string.append(':');
+      if (getMinutes() < 10)
+         string.append('0');
+      string.append(getMinutes());
+
+      if (getAmPm() == Calendar.AM) {
+         string.append(" AM");
+      } else {
+         string.append(" PM");
+      }
+      return string.toString();
+   }
+
+   // Misc. methods
+
+   public static Time getTimeFromSqlTime(java.sql.Time sqlTime) {
+      // staticlogger.info("sqlTime "+ sqlTime.toString());
+      long ms = sqlTime.getTime();
+      java.util.Calendar gcal = GregorianCalendar.getInstance();
+      gcal.setTime(new Date(ms));
+      Time time = new Time(gcal.get(Calendar.HOUR_OF_DAY), gcal
+            .get(Calendar.MINUTE), gcal.get(Calendar.SECOND));
+      return time;
+   }
+
+   public static void main(String args[]) {
+      Time time = new Time(12, 00, 00);
+      System.out.println(time);
+   }
+}

src/edu/cornell/mannlib/semservices/service/ExternalConceptService.java

@@ -0,0 +1,11 @@
+package edu.cornell.mannlib.semservices.service;
+
+import java.util.List;
+
+import edu.cornell.mannlib.semservices.bo.Concept;
+
+public interface ExternalConceptService {
+   // this is the only method that needs to be exposed
+   List<Concept> processResults(String term);
+
+}

src/edu/cornell/mannlib/semservices/service/impl/AgrovocService.java

@@ -0,0 +1,494 @@
+package edu.cornell.mannlib.semservices.service.impl;
+
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.StringWriter;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.rmi.RemoteException;
+import java.util.ArrayList;
+import java.util.List;
+
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.rpc.ServiceException;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.fao.gilw.aims.webservices.AgrovocWS;
+import org.fao.gilw.aims.webservices.AgrovocWSServiceLocator;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+import edu.cornell.mannlib.semservices.bo.Concept;
+import edu.cornell.mannlib.semservices.service.ExternalConceptService;
+import edu.cornell.mannlib.semservices.util.XMLUtils;
+
+public class AgrovocService implements ExternalConceptService  {
+   protected final Log logger = LogFactory.getLog(getClass());
+   private java.lang.String AgrovocWS_address = "http://www.fao.org/webservices/AgrovocWS";
+
+   public List<Concept> processResults(String term) {
+      List<Concept> conceptList = new ArrayList<Concept>();
+
+      String termcode;
+      try {
+         termcode = getTermcodeByTerm(term);
+      } catch (Exception e1) {
+         logger.error("Could not get termcode from service", e1);
+         return null;
+      }
+
+      String format = "SKOS";
+      // if the termcode is null it means that either the service is not responding
+      // or there was not a match for the string
+      //System.out.println("Got termcode: "+termcode);
+
+      String results = getConceptInfoByTermcodeXML(termcode, format);
+
+      //XMLUtils.prettyPrint(results);
+
+      try {
+         Document doc = XMLUtils.parse(results);
+         String prefLabelQuery = "child::*[@xml:lang='EN']";
+         NodeList nodes = doc.getElementsByTagName("skos:Concept");
+         //System.out.println("Found this many nodes: "+ nodes.getLength());
+         for (int i=0; i < nodes.getLength(); i++) {
+
+            Node node = nodes.item(i);
+            //XMLUtils.serializeNode(node); System.out.println();
+
+            Concept concept = new Concept();
+            concept.setDefinedBy("Agrovoc");
+            concept.setConceptId(termcode);
+
+            NamedNodeMap attrs = node.getAttributes();
+            Attr idAttr = (Attr) attrs.getNamedItem("rdf:about");
+            String conceptUri = idAttr.getTextContent();
+            concept.setUri(conceptUri);
+
+            Node prefLabelNode = XMLUtils.getNodeWithXpath(node, prefLabelQuery);
+            if (prefLabelNode != null) {
+               String prefLabel = prefLabelNode.getTextContent();
+               concept.setLabel(prefLabel);
+            }
+            conceptList.add(concept);
+         }
+      } catch (IOException e) {
+         e.printStackTrace();
+      } catch (SAXException e) {
+         e.printStackTrace();
+      } catch (ParserConfigurationException e) {
+         e.printStackTrace();
+      }
+      return conceptList;
+      //JSONObject jsonObject = null;
+      //jsonObject = BeanToJsonSerializer.serializeToJsonObject(conceptList);
+      //return jsonObject.toString();
+   }
+
+
+   protected String getAgrovocLanguages() {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getAgrovocLanguages();
+      } catch (ServiceException e) {
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String getTermcodeByTerm(String term) throws Exception {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getTermcodeByTerm(term);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         throw e;
+      }  catch (RemoteException e) {
+         logger.error("remote exception", e);
+         throw e;
+      } catch (MalformedURLException e) {
+         logger.error("malformed URL exception", e);
+         throw e;
+      }
+      return result;
+   }
+
+   protected String getTermcodeByTermXML(String term, String format) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getTermcodeByTermXML(term, format);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+      return result;
+   }
+
+   protected String getTermByLanguage(int termcode, String language) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getTermByLanguage(termcode, language);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+      return result;
+   }
+
+   protected String getTermByLanguageXML(int termcode, String language, String format) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getTermByLanguageXML(termcode, language, format);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String getTermsListByLanguage2(String termcodes, String language, String sep) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getTermsListByLanguage2(termcodes, language, sep);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+      return result;
+   }
+
+   protected String getTermsListByLanguageXML(String termcodes, String language, String format) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getTermsListByLanguageXML(termcodes, language, format);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String getAllLabelsByTermcode2(int termcode, String sep) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getAllLabelsByTermcode2(termcode, sep);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String getAllLabelsByTermcodeXML(int termcode, String format) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getAllLabelsByTermcodeXML(termcode, format);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String simpleSearchByMode2(String term, String mode, String sep ) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.simpleSearchByMode2(term, mode, sep);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String simpleSearchByModeXML(String term, String mode, String format) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.simpleSearchByModeXML(term, mode, format);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String searchByTerm2(String term, String sep) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.searchByTerm2(term, sep);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String searchByTermXML(String term, String format) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.searchByTermXML(term, format);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String searchCategoryByMode(String term, String lang, String schemeid, String mode, String sep) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.searchCategoryByMode(term, lang, schemeid, mode, sep);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String searchCategoryByModeXML(String term, String mode, String schemeid, String lang, String format) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.searchCategoryByModeXML(term, mode, schemeid, lang, format);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String[] getConceptInfoByTermcode(String termcode) {
+      String result[] = null;
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getConceptInfoByTermcode(termcode);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String getConceptInfoByTermcodeXML(String termcode, String format) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getConceptInfoByTermcodeXML(termcode, format);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String[] getDefinitions(int termcode, String lang) {
+      String[] result = null;
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getDefinitions(termcode, lang);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String getDefinitionsXML(int termcode, String lang, String format) {
+      String result = null;
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getDefinitionsXML(termcode, lang, format);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String getTermExpansion(String aQuery, String langugage) {
+      String result = new String();
+      AgrovocWSServiceLocator locator = new AgrovocWSServiceLocator();
+      try {
+         URL url = new URL(AgrovocWS_address);
+         AgrovocWS agrovoc_service = locator.getAgrovocWS(url);
+         result = agrovoc_service.getTermExpansion(aQuery, langugage);
+      } catch (ServiceException e) {
+         logger.error("service exception", e);
+         e.printStackTrace();
+      }  catch (RemoteException e) {
+         e.printStackTrace();
+      } catch (MalformedURLException e) {
+         e.printStackTrace();
+      }
+
+      return result;
+   }
+
+   protected String getWsdl() {
+      String result = new String();
+      try {
+
+         StringWriter sw = new StringWriter();
+         URL rss = new URL(AgrovocWS_address + "?wsdl");
+
+         BufferedReader in = new BufferedReader(new InputStreamReader(rss.openStream()));
+         String inputLine;
+         while ((inputLine = in.readLine()) != null) {
+            sw.write(inputLine);
+         }
+         in.close();
+
+         result = sw.toString();
+
+      } catch (Exception ex) {
+         logger.error("error occurred in servlet", ex);
+      }
+      return result;
+   }
+}

src/edu/cornell/mannlib/semservices/service/impl/UMLSService.java

@@ -0,0 +1,152 @@
+package edu.cornell.mannlib.semservices.service.impl;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.StringWriter;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.List;
+
+import net.sf.json.JSONArray;
+import net.sf.json.JSONObject;
+import net.sf.json.JSONSerializer;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import edu.cornell.mannlib.semservices.bo.Concept;
+import edu.cornell.mannlib.semservices.service.ExternalConceptService;
+
+/**
+ * @author jaf30
+ *
+ */
+public class UMLSService implements ExternalConceptService {
+   protected final Log logger = LogFactory.getLog(getClass());
+   private static final String submissionUrl = "http://link.informatics.stonybrook.edu/MeaningLookup/MlServiceServlet?";
+   private static final String baseUri = "http://link.informatics.stonybrook.edu/umls/CUI/";
+
+   public List<Concept> processResults(String term) {
+      String results = null;
+      String dataUrl = submissionUrl + "textToProcess="
+            + URLEncoder.encode(term) + "&format=json";
+
+      try {
+
+         StringWriter sw = new StringWriter();
+         URL rss = new URL(dataUrl);
+
+         BufferedReader in = new BufferedReader(new InputStreamReader(rss.openStream()));
+         String inputLine;
+         while ((inputLine = in.readLine()) != null) {
+            sw.write(inputLine);
+         }
+         in.close();
+
+         results = sw.toString();
+
+      } catch (Exception ex) {
+         logger.error("error occurred in servlet", ex);
+         return null;
+      }
+      //System.out.println("results before processing: "+results);
+      List<Concept> conceptList = processOutput(results);
+      return conceptList;
+   }
+
+   /**
+    * @param results
+    * @return
+    */
+   private List<Concept> processOutput(String results) {
+
+      List<Concept> conceptList = new ArrayList<Concept>();
+      List<String> bestMatchIdList = new ArrayList<String>();
+      String bestMatchId = new String();
+      try {
+         JSONObject json = (JSONObject) JSONSerializer.toJSON( results );
+
+         if (json.has("Best Match")) {
+            //System.out.println("Best Match");
+
+            JSONArray bestMatchArray = json.getJSONArray("Best Match");
+            int len = bestMatchArray.size();
+            if (len > 1) {
+               System.out.println("Found this many best matches: "+ len);
+            }
+            int i;
+            for (i = 0; i < len; i++) {
+               JSONObject o = bestMatchArray.getJSONObject(i);
+               //System.out.println(o.toString());
+               Concept concept = new Concept();
+               concept.setDefinedBy("UMLS");
+               concept.setBestMatch("true");
+               String cui = getJsonValue(o, "CUI");
+               bestMatchIdList.add(cui);
+
+               concept.setConceptId(cui);
+               concept.setLabel(getJsonValue(o, "label"));
+               concept.setType(getJsonValue(o, "type"));
+               concept.setDefinition(getJsonValue(o, "definition"));
+               concept.setUri(baseUri + cui);
+               conceptList.add(concept);
+            }
+         }
+         if (json.has("All")) {
+
+            JSONArray allArray = json.getJSONArray("All");
+            int len = allArray.size();
+            //System.out.println("size of best match array: "+ len);
+            int i;
+            for (i = 0; i < len; i++) {
+               JSONObject o = allArray.getJSONObject(i);
+               //System.out.println(o.toString());
+               Concept concept = new Concept();
+               concept.setDefinedBy("UMLS");
+               String cui = getJsonValue(o, "CUI");
+               concept.setConceptId(cui);
+
+               concept.setLabel(getJsonValue(o, "label"));
+               concept.setType(getJsonValue(o, "type"));
+               concept.setDefinition(getJsonValue(o, "definition"));
+               concept.setUri(baseUri + cui);
+               // prevent duplicate concepts in list
+               if (! bestMatchIdList.contains(cui)) {
+                  concept.setBestMatch("false");
+                  conceptList.add(concept);
+               }
+            }
+         }
+      } catch (Exception ex ) {
+         ex.printStackTrace();
+         logger.error("Could not get concepts", ex);
+      }
+      return conceptList;
+
+      //
+      // now serialize the list of Concepts to a JSON String
+      //
+      //JSONObject jsonObject = null;
+      //jsonObject = BeanToJsonSerializer.serializeToJsonObject(conceptList);
+      //System.out.println(jsonObject.toString());
+      //return jsonObject.toString();
+
+   }
+
+
+   /**
+    * Get a string from a json object or an empty string if there is no value for the given key
+   * @param obj
+   * @param key
+   * @return
+   */
+  protected String getJsonValue(JSONObject obj, String key) {
+      if (obj.has(key)) {
+         return obj.getString(key);
+      } else {
+         return new String("");
+      }
+   }
+
+}

src/edu/cornell/mannlib/semservices/util/ClassUtils.java

@@ -0,0 +1,152 @@
+/*
+ * $Id$
+ * CONFIDENTIAL AND PROPRIETARY. ? 2007 Revolution Health Group LLC. All rights reserved.
+ * This source code may not be disclosed to others, used or reproduced without the written permission of Revolution Health Group.
+ *
+ */
+package edu.cornell.mannlib.semservices.util;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.log4j.Logger;
+
+
+public class ClassUtils {
+   public static final String VERSION = "$Rev$";
+   private static final Logger LOG = Logger.getLogger(ClassUtils.class);
+
+   private ClassUtils() {}
+
+   @SuppressWarnings("unchecked")
+   public static Method[] getMethods(Class<?> clazz) {
+      if (Proxy.isProxyClass(clazz) && clazz.getInterfaces().length > 0 ) {
+         return clazz.getInterfaces()[0].getDeclaredMethods();
+      }
+
+      ArrayList<Method> methods = new ArrayList<Method>();
+      Class<?> interfaceClass = clazz;
+      // only change our classes
+      if ((interfaceClass.getPackage().getName().indexOf("java") != 0) && (interfaceClass != null)) {
+         if (!interfaceClass.isInterface()) {
+            Class[] interfaces = interfaceClass.getInterfaces();
+            for (Class interfaceTemp : interfaces) {
+               if (interfaceTemp.isInterface()) {
+                  methods.addAll(Arrays.asList(interfaceTemp.getMethods()));
+               }
+            }
+         } else {
+            methods.addAll(Arrays.asList(interfaceClass.getMethods()));
+         }
+      }
+
+      if (methods.isEmpty()) {
+          methods.addAll(Arrays.asList(clazz.getDeclaredMethods()));
+      }
+
+      return methods.toArray(new Method[methods.size()]);
+   }
+
+   public static Object findEnumConstant(Class<Object> enumType, Object findConst) {
+      Object result = null;
+      Object[] enumConstants = enumType.getEnumConstants();
+      for (Object enumConst : enumConstants) {
+         if (enumConst.toString().equals(findConst.toString())) {
+            result = enumConst;
+            break;
+         }
+      }
+
+      if (result == null && findConst != null) { // last try for XmlEnum..
+         result = getXmlEnumFromValue(enumType, findConst.toString());
+      }
+
+      return result;
+   }
+
+   @SuppressWarnings("unchecked")
+   public static boolean isXmlEnum(Class<? extends Object> class1) {
+      boolean result = false;
+      try {
+         Class xmlEnumClass = Class.forName("javax.xml.bind.annotation.XmlEnum");
+         result = (xmlEnumClass != null) && (class1.getAnnotation(xmlEnumClass) != null);
+      } catch (ClassNotFoundException e) {
+         LOG.info("Class Not Found: javax.xml.bind.annotation.XmlEnum, this is ok if you aren't serializing JaxB Objects");
+      }
+
+      return result;
+   }
+
+
+   public static Object getXmlEnumFromValue(Class<Object> enumType, String findConst) {
+      Object result = null;
+      try {
+         if (isXmlEnum(enumType)) {
+            // XmlEnum will have a "fromValue" method to convert the const to the enum const
+            Method fromValue = enumType.getMethod("fromValue", String.class);
+            result = fromValue.invoke(enumType, findConst);
+         }
+      } catch (Exception e) {
+         // could happen..just give up and return null
+      }
+      return result;
+   }
+
+   public static boolean isArrayType(Class<?> type) {
+      return List.class.isAssignableFrom(type);
+   }
+
+   public static boolean isMapType(Class<?> type) {
+      return Map.class.isAssignableFrom(type);
+   }
+
+   public static Class<?> getArrayElementType(Method method, int paramIndex) {
+      Type[] types = method.getGenericParameterTypes();
+      if (types.length > paramIndex) {
+         return getArrayElementType(types[paramIndex]);
+      }
+      return null;
+   }
+
+   public static Class<?> getArrayElementType(Type genericType) {
+      Class<?> result = null;
+
+      if (genericType instanceof ParameterizedType) {
+         ParameterizedType pt = (ParameterizedType) genericType;
+         //Type raw = pt.getRawType();
+         //Type owner = pt.getOwnerType();
+         Type[] typeArgs = pt.getActualTypeArguments();
+         if (typeArgs[0] instanceof GenericArrayType) {
+            Class<?> arrayElementType = (Class<?>) ((GenericArrayType) typeArgs[0])
+                                   .getGenericComponentType();
+            result = arrayElementType;
+         } else if (typeArgs[0] instanceof Class<?>){
+            result = (Class<?>) typeArgs[0];
+         }
+      }
+
+      return result;
+   }
+
+   @SuppressWarnings("unchecked")
+   public static boolean hasEmptyConstructor(Class<?> type) {
+      boolean result = false;
+      Constructor[] constructors = type.getDeclaredConstructors();
+      for (Constructor constructor : constructors) {
+         if (constructor.getParameterTypes().length == 0) {
+            result = true;
+            break;
+         }
+      }
+
+      return result;
+   }
+}

src/edu/cornell/mannlib/semservices/util/DateConverter.java

@@ -0,0 +1,141 @@
+/*
+ * $Id: DateConverter.java 50408 2007-03-28 19:14:46Z jdamick $
+ *
+ * Copyright 2006- Revolution Health Group.  All rights reserved.
+ *
+ * This software is the confidential and proprietary information
+ * of Revolution Health Group.  (Confidential Information).
+ * You shall not disclose such Confidential Information and shall
+ * use it only in accordance with the terms of the license
+ * agreement you entered into with Revolution Health Group.
+ *
+ */
+
+package edu.cornell.mannlib.semservices.util;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import org.apache.commons.beanutils.ConversionException;
+import org.apache.commons.beanutils.Converter;
+import org.apache.log4j.Logger;
+import net.sf.json.JSONException;
+import net.sf.json.JSONObject;
+
+public final class DateConverter implements Converter {
+    private static final Logger LOG = Logger.getLogger(DateConverter.class);
+
+    //  Constructors
+
+    /**
+     * Create a {@link Converter} that will throw a {@link ConversionException}
+     * if a conversion error occurs.
+     */
+    public DateConverter() {
+        this.defaultValue = null;
+        converter = new XMLGregorianCalendarConverter(defaultValue);
+    }
+
+    /**
+     * Create a {@link Converter} that will return the specified default value
+     * if a conversion error occurs.
+     *
+     * @param defaultValue
+     *            The default value to be returned
+     */
+    public DateConverter(Object defaultValue) {
+        this.defaultValue = defaultValue;
+        converter = new XMLGregorianCalendarConverter(defaultValue);
+    }
+
+    //  Instance Variables
+
+    /**
+     * The default value specified to our Constructor, if any.
+     */
+    private Object defaultValue = null;
+    private XMLGregorianCalendarConverter converter = null;
+
+    // --------------------------------------------------------- Public Methods
+
+    /**
+     * Convert the specified input object into an output object of the specified
+     * type.
+     *
+     * @param type
+     *   XMLGregorianCalendar type to which this value should be
+     *   converted
+     * @param value
+     *   The input value to be converted
+     *
+     * @exception ConversionException
+     *    if conversion cannot be performed successfully
+     */
+    @SuppressWarnings({ "unchecked", "deprecation" })
+   public Object convert(Class type, Object value) {
+
+        String dateValue = value.toString();
+
+        if (value instanceof Date) {
+            return (value);
+        } else {
+            try {
+                JSONObject jsonObj = JSONObject.fromObject(value.toString());
+                dateValue = jsonObj
+                        .optString("Date" /* Date.class.toString() */);
+            } catch (JSONException e) { /* empty, could fail.. */
+                LOG.debug("no date object found in the json");
+            }
+        }
+        XMLGregorianCalendar calendar = (XMLGregorianCalendar) converter
+                .convert(type, dateValue);
+
+        Object result = null;
+        try {
+            result = calendar.toGregorianCalendar().getTime();
+        } catch (Exception exception) { /*
+                                         * empty, had some error parsing the
+                                         * time
+                                         */
+            LOG.debug("Error converting the time");
+            if (result == null) {
+                try {
+                    result = new Date(Date.parse(dateValue));
+                } catch (IllegalArgumentException argException) {
+                    // last chance
+                    result = java.sql.Date.valueOf(dateValue);
+                }
+            }
+        }
+
+        if (result != null && (result instanceof Date)
+                && type.equals(java.sql.Date.class)) {
+            result = new java.sql.Date(((Date) result).getTime());
+        }
+
+        return result;
+    }
+
+    public static XMLGregorianCalendar toXMLGregorianCalendar(Date date) {
+        try {
+            GregorianCalendar calendar = new GregorianCalendar();
+            calendar.setTime(date);
+            return DatatypeFactory.newInstance().newXMLGregorianCalendar(
+                    calendar);
+        } catch (DatatypeConfigurationException e) {
+            return null;
+        }
+    }
+
+    public static String toFormattedString(Date date) {
+        String s = new String();
+        s = new SimpleDateFormat("MMM d, h:mm a").format(date.getTime());
+        return s;
+    }
+}

src/edu/cornell/mannlib/semservices/util/DateUtils.java

@@ -0,0 +1,195 @@
+package edu.cornell.mannlib.semservices.util;
+
+import java.text.ParsePosition;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+public class DateUtils {
+   /** Logger for this class and subclasses */
+   protected final Log logger = LogFactory.getLog(getClass());
+
+   public static final Long MILLISECONDSINDAY = 86400L;
+   public static final Long MILLISECONDSINYEAR = MILLISECONDSINDAY * 365;
+
+   public static String getToday(String fmt) {
+      String today;
+      Calendar now = Calendar.getInstance();
+      SimpleDateFormat formatter = new SimpleDateFormat("yyyy-dd-MM");
+      today = formatter.format(now.getTime());
+      return today;
+   }
+
+   public static String getCurrentYear() {
+      String y;
+      Calendar now = Calendar.getInstance();
+      SimpleDateFormat formatter = new SimpleDateFormat("yyyy");
+      y = formatter.format(now.getTime());
+      return y;
+   }
+
+
+   /**
+    * Get Current Jave Date
+    *
+    * returns a date in following format: Tue Apr 01 08:21:57 EST 2003
+    */
+   public static java.util.Date getCurrentJavaDate() {
+      java.util.Date currentDate = new java.util.Date();
+      return currentDate;
+   }
+
+   /**
+    * get Current SQL date
+    *
+    * returns a date in following format: 2003-04-01
+    */
+   public static java.sql.Date getCurrentSQLDate() {
+      java.util.Date currentDate = new java.util.Date();
+      java.sql.Date sqlDate = new java.sql.Date(currentDate.getTime());
+      return sqlDate;
+   }
+
+   /**
+    * get current SQL Timestamp
+    *
+    * returns a date in following format: 2003-04-01 08:21:57.556
+    */
+   public static java.sql.Timestamp getCurrentSQLTimestamp() {
+      java.sql.Timestamp sqlTime = new java.sql.Timestamp(System.currentTimeMillis());
+      return sqlTime;
+   }
+
+   /**
+    * returns a formatted date/time as a string
+    *
+    * returns a date in the following format 01-04-03 08:21:57
+    */
+   public static String getFormattedDate() {
+      String s = null;
+      Calendar today = Calendar.getInstance();
+      s = new SimpleDateFormat("dd-MM-yy hh:mm:ss").format(today.getTime());
+      return s;
+   }
+
+   /**
+    * returns a formatted date/time as a string
+    * @param a format string
+    * @return the current date in the specified format
+    */
+   public static String getFormattedDate(String f) {
+      String s = null;
+      Calendar today = Calendar.getInstance();
+      s = new SimpleDateFormat(f).format(today.getTime());
+      return s;
+   }
+
+   /**
+    * given a String date in a described format (i.e. YYYY-mm-dd) convert
+    * it to a String date in a new format (i.e. MM-dd-YYYY)
+    *
+    * @param s input date string
+    * @param formatin a format string
+    * @param formatout a format string
+    * @return formated date string
+    */
+   public static String convertStringDate(String s, String formatIn, String formatOut) {
+
+      try {
+        if (s.equals("now")) {
+          return (new SimpleDateFormat(formatOut).format(new java.util.Date()));
+        } else {
+          return (new SimpleDateFormat(formatOut)).format(
+                 (new SimpleDateFormat(formatIn)).parse(
+                   s, new ParsePosition(0)));
+        }
+      } catch( Exception e ) {
+        return "";
+      }
+
+   }
+
+   /**
+    * returns a Date given a formatted string
+    */
+   public static java.util.Date setDate(String s) {
+      SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yy hh:mm:ss");
+      ParsePosition pos = new ParsePosition(0);
+      java.util.Date newDate = formatter.parse(s, pos);
+      return newDate;
+   }
+
+   /**
+    * returns a Date given a formatted string
+    */
+   public static java.util.Date setDate(String s, String fmt) {
+      SimpleDateFormat formatter = new SimpleDateFormat(fmt);
+      ParsePosition pos = new ParsePosition(0);
+      java.util.Date newDate = formatter.parse(s, pos);
+      return newDate;
+   }
+
+   /**
+    * returns a SQL Date given a formatted string
+    */
+   public static java.sql.Date getSQLDateFromString(String s) {
+      return java.sql.Date.valueOf(s);
+   }
+
+   /**
+    * returns a SQL Time given a formatted string
+    */
+   public static java.sql.Time getSQLTimeFromString(String s) {
+      return java.sql.Time.valueOf(s);
+   }
+
+   /*
+    * return  a formatted version of a java.sqlDate
+    */
+   public static String getFormattedDate(java.util.Date date, String fmt) {
+      String formattedDate = new String();
+      formattedDate = new SimpleDateFormat(fmt).format(new java.util.Date(date.getTime()));
+      return formattedDate;
+   }
+
+   /*
+    * return  a formatted version of a java.sqlDate
+    */
+   public static String getFormattedSQLDate(java.sql.Date sqldate, String fmt) {
+      String formattedDate = new String();
+      formattedDate = new SimpleDateFormat(fmt).format(new java.util.Date(sqldate.getTime()));
+      return formattedDate;
+   }
+
+
+   public static java.sql.Date getNextSQLDate(java.sql.Date currentDate) {
+      Calendar cal = Calendar.getInstance();
+      cal.setTime(currentDate);
+      cal.add(Calendar.DATE, 1);
+      java.util.Date tomorrow = cal.getTime();
+      return new java.sql.Date(tomorrow.getTime());
+   }
+
+   /**
+   * @param start
+   * @param end
+   * @return elapsed time
+   */
+   public static String getElapsedTime(String start, String end) {
+      long startlong = Long.parseLong(start, 10);
+      long endlong = Long.parseLong(end, 10);
+      long elapsed = endlong - startlong;
+      return Long.toString(elapsed, 10);
+   }
+
+   /**
+    * returns a SQL Timestamp given a formatted string
+    */
+   public static java.sql.Timestamp convertSQLTimestamp(String s, String formatIn, String formatOut) {
+      String s2 = convertStringDate(s, formatIn, formatOut);
+      //System.out.println("s2: "+s2);
+      return java.sql.Timestamp.valueOf(s2+".0");
+   }
+
+}

src/edu/cornell/mannlib/semservices/util/DayConverter.java

@@ -0,0 +1,78 @@
+package edu.cornell.mannlib.semservices.util;
+
+
+
+import java.util.Date;
+import org.apache.commons.beanutils.Converter;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import edu.cornell.mannlib.semservices.bo.Day;
+
+public class DayConverter implements Converter {
+   @SuppressWarnings("unused")
+   private static final Log logger = LogFactory.getLog(DayConverter.class);
+    /**
+     * The default value specified to our Constructor, if any.
+     */
+    @SuppressWarnings("unused")
+   private Object defaultValue = null;
+
+    /**
+     * Should we return the default value on conversion errors?
+     */
+    @SuppressWarnings("unused")
+   private boolean useDefault = true;
+
+
+   /**
+    * Constructor
+    */
+   public DayConverter() {
+      this.defaultValue = null;
+      this.useDefault = false;
+   }
+
+   /**
+    * Constructor with object
+    * @param defaultValue
+    */
+   public DayConverter(Object defaultValue) {
+      this.defaultValue = defaultValue;
+      this.useDefault = true;
+   }
+
+    /* (non-Javadoc)
+    * @see org.apache.commons.beanutils.Converter#convert(java.lang.Class, java.lang.Object)
+    */
+   @SuppressWarnings("unchecked")
+   public Object convert(Class type, Object value) {
+        String s = value.toString();
+        return s;
+    }
+
+    /**
+     * Format the output to something reasonable
+    * @param day
+    * @return
+    */
+   public static String toFormattedString(Object day) {
+       Day dayObject = (Day) day;
+       String s = dayObject.getDayName()+
+           ", "+dayObject.getMonthName()+
+           " "+dayObject.getDayOfMonth()+
+           ", "+dayObject.getYear();
+       return s;
+   }
+
+   public static String toUnixTime(Object day) {
+      // get date in milliseconds and divide by zero to return unixtime
+      Day dayObject = (Day) day;
+      Date date = dayObject.getDate();
+      Long seconds = date.getTime() / 1000;
+      //logger.info("unixtime: " + seconds.toString());
+      return seconds.toString();
+   }
+
+
+}

src/edu/cornell/mannlib/semservices/util/MetadataNamespaceContext.java

@@ -0,0 +1,24 @@
+package edu.cornell.mannlib.semservices.util;
+import java.util.Iterator;
+import javax.xml.XMLConstants;
+import javax.xml.namespace.NamespaceContext;
+
+public class MetadataNamespaceContext implements NamespaceContext {
+    public String getNamespaceURI(String prefix) {
+        if (prefix == null) throw new NullPointerException("Null prefix");
+        else if ("mix".equals(prefix)) return "http://www.loc.gov/mix/";
+        else if ("xml".equals(prefix)) return XMLConstants.XML_NS_URI;
+        return XMLConstants.NULL_NS_URI;
+    }
+
+    // This method isn't necessary for XPath processing.
+    public String getPrefix(String uri) {
+        throw new UnsupportedOperationException();
+    }
+
+    // This method isn't necessary for XPath processing either.
+    public Iterator getPrefixes(String uri) {
+        throw new UnsupportedOperationException();
+    }
+
+}

src/edu/cornell/mannlib/semservices/util/ObjectUtils.java

@@ -0,0 +1,268 @@
+/*
+ * $Id$
+ * CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+ * This source code may not be disclosed to others, used or reproduced without the written permission of Revolution Health Group.
+ *
+ */
+package edu.cornell.mannlib.semservices.util;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+public class ObjectUtils {
+   public static final String VERSION = "$Rev: 63219 $";
+   private static final Log logger = LogFactory.getLog(ObjectUtils.class);
+
+   @SuppressWarnings("unchecked")
+  private static final Set<Class> SIMPLE_TYPES = new HashSet<Class>() {
+       /**
+      *
+      */
+     private static final long serialVersionUID = 1L;
+
+     {
+           add(Boolean.class);
+           add(boolean.class);
+           add(Float.class);
+           add(float.class);
+           add(Double.class);
+           add(double.class);
+           add(Integer.class);
+           add(int.class);
+           add(Long.class);
+           add(long.class);
+           add(Short.class);
+           add(short.class);
+           add(Byte.class);
+           add(byte.class);
+           add(String.class);
+           add(BigDecimal.class);
+           add(BigInteger.class);
+       }
+   };
+
+   /**
+    *
+    */
+   private ObjectUtils() {
+   }
+
+   /**
+    * @param obj
+    * @return
+    */
+   @SuppressWarnings("unchecked")
+  public static boolean isMap(Object obj) {
+       if (obj instanceof Map) {
+           return true;
+       }
+       return false;
+   }
+
+
+   /**
+    * @param obj
+    * @return
+    */
+   public static boolean isBigDecimal(Object obj) {
+      if (obj instanceof BigDecimal) {
+         return true;
+      }
+      return false;
+   }
+
+   /**
+    * @param obj
+    * @return
+    */
+   public static boolean isArray(Object obj) {
+       if (obj != null) {
+           return isClassArray(obj.getClass());
+       }
+       return false;
+   }
+
+   /**
+    * @param clazz
+    * @return
+    */
+   @SuppressWarnings("unchecked")
+  public static boolean isClassArray(Class clazz) {
+       if (clazz.isArray()) {
+           return true;
+       }
+       if (Collection.class.isAssignableFrom(clazz)) {
+           return true;
+       }
+       return false;
+   }
+
+   /**
+    * @param obj
+    * @return
+    */
+   public static boolean isSimpleType(Object obj) {
+       boolean result = false;
+       if (obj != null) {
+           result = isClassSimpleType(obj.getClass());
+       }
+
+       return result;
+   }
+
+   /**
+    * @param clazz
+    * @return
+    */
+   @SuppressWarnings("unchecked")
+  public static boolean isClassSimpleType(Class clazz) {
+       boolean result = false;
+       if (clazz != null && SIMPLE_TYPES.contains(clazz)) {
+           result = true;
+       }
+       return result;
+   }
+
+   /**
+    * @param value
+    * @return
+    */
+   @SuppressWarnings("unchecked")
+  public static boolean isComplex(Object value) {
+       Class type = value.getClass();
+       return !(isSimpleType(value) || type.isEnum());
+   }
+
+   /**
+    * @param enumObj
+    * @return
+    */
+   @SuppressWarnings("unchecked")
+  public static String getXmlEnumValue(Object enumObj) {
+       String result = null;
+       try {
+           if (ClassUtils.isXmlEnum((Class<Object>) enumObj.getClass())) {
+               // XmlEnum will have a "fromValue" method to convert the const
+               // to the enum const
+               Method value = enumObj.getClass().getMethod("value");
+               result = value.invoke(enumObj).toString();
+           }
+       } catch (Exception e) {
+           // could happen..just give up and return null
+       }
+       return result;
+   }
+
+   /**
+    * @param o
+    */
+   public static void printBusinessObject(Object o) {
+      Field[] fields = o.getClass().getDeclaredFields();
+
+      for (int i = 0; i < fields.length; i++) {
+         Field field = fields[i];
+         try {
+            field.setAccessible(true);
+            System.out.println(field.getName()+": "+field.get(o));
+         }
+         catch (IllegalAccessException e) {
+            System.err.println("Illegal access exception");
+         } catch (NullPointerException e) {
+            System.err.println("Nullpointer Exception");
+         }
+      }
+      System.out.println();
+   }
+
+   /**
+    * @param o
+    * @param fieldnames
+    */
+   public static void printBusinessObject(Object o, List<String> fieldnames)  {
+      Field[] fields = new Field[fieldnames.size()];
+      int f = 0;
+      for (String s: fieldnames) {
+         try {
+           fields[f++] = o.getClass().getDeclaredField(s);
+        } catch (SecurityException e) {
+           // TODO Auto-generated catch block
+           e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+           // TODO Auto-generated catch block
+           e.printStackTrace();
+        }
+      }
+
+      for (int i = 0; i < fields.length; i++) {
+         Field field = fields[i];
+         try {
+            field.setAccessible(true);
+            System.out.println(field.getName()+": "+field.get(o));
+         }
+         catch (IllegalAccessException e) {
+            System.err.println("Illegal access exception");
+         } catch (NullPointerException e) {
+            System.err.println("Nullpointer Exception");
+         }
+      }
+      System.out.println();
+   }
+
+   /**
+    * @param o
+    */
+   public static void logBusinessObject(Object o) {
+      Field[] fields = o.getClass().getDeclaredFields();
+
+      for (int i = 0; i < fields.length; i++) {
+         Field field = fields[i];
+         try {
+            field.setAccessible(true);
+            logger.info(field.getName()+": "+field.get(o));
+         }
+         catch (IllegalAccessException e) {
+            logger.error("Illegal access exception");
+         } catch (NullPointerException e) {
+            logger.error("Nullpointer Exception");
+         }
+
+      }
+   }
+
+   /**
+    * @param mapobject
+    */
+   public static void printMapObject(Map<?, ?> mapobject) {
+      Iterator<?> iter = mapobject.keySet().iterator();
+      while (iter.hasNext()) {
+         Object keyobj = iter.next();
+         Object valobj = mapobject.get(keyobj);
+         System.out.println(keyobj +": "+ valobj);
+      }
+   }
+
+   /**
+    * @param mapobject
+    */
+   public static void logMapObject(Map<?, ?> mapobject) {
+      Iterator<?> iter = mapobject.keySet().iterator();
+      while (iter.hasNext()) {
+         Object keyobj = iter.next();
+         Object valobj = mapobject.get(keyobj);
+         logger.info(keyobj +": "+ valobj);
+      }
+   }
+
+
+}

src/edu/cornell/mannlib/semservices/util/TimeConverter.java

@@ -0,0 +1,72 @@
+package edu.cornell.mannlib.semservices.util;
+import edu.cornell.mannlib.semservices.bo.Time;
+import java.util.Date;
+
+import org.apache.commons.beanutils.Converter;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+
+
+public class TimeConverter implements Converter {
+   @SuppressWarnings("unused")
+   private static final Log logger = LogFactory.getLog(TimeConverter.class);
+
+   /**
+    * The default value specified to our Constructor, if any.
+    */
+   @SuppressWarnings("unused")
+   private Object defaultValue = null;
+
+   /**
+    * Should we return the default value on conversion errors?
+    */
+   @SuppressWarnings("unused")
+   private boolean useDefault = true;
+
+   /**
+     *
+     */
+   public TimeConverter() {
+      this.defaultValue = null;
+      this.useDefault = false;
+   }
+
+   /**
+    * @param defaultValue
+    */
+   public TimeConverter(Object defaultValue) {
+      this.defaultValue = defaultValue;
+      this.useDefault = true;
+   }
+
+   /* (non-Javadoc)
+    * @see org.apache.commons.beanutils.Converter#convert(java.lang.Class, java.lang.Object)
+    */
+   @SuppressWarnings("unchecked")
+   public Object convert(Class type, Object value) {
+      String s = value.toString();
+      return s;
+   }
+
+   /**
+    * @param time
+    * @return
+    */
+   public static String toFormattedString(Object time) {
+      return time.toString();
+   }
+
+   /**
+    * @param time
+    * @return
+    */
+   public static String toUnixTime(Object time) {
+      Time timeObject = (Time) time;
+      Date date = timeObject.getDate();
+      Long seconds = date.getTime() / 1000;
+      //logger.info("unixtime: " + seconds.toString());
+      return seconds.toString();
+   }
+
+}

src/edu/cornell/mannlib/semservices/util/TimestampConverter.java

@@ -0,0 +1,63 @@
+package edu.cornell.mannlib.semservices.util;
+import java.sql.Timestamp;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import org.apache.commons.beanutils.Converter;
+
+public class TimestampConverter implements Converter {
+    /**
+     * The default value specified to our Constructor, if any.
+     */
+    @SuppressWarnings("unused")
+   private Object defaultValue = null;
+
+    /**
+     * Should we return the default value on conversion errors?
+     */
+    @SuppressWarnings("unused")
+    private boolean useDefault = true;
+
+
+     /**
+     *
+     */
+    public TimestampConverter() {
+        this.defaultValue = null;
+        this.useDefault = false;
+    }
+
+    /**
+    * @param defaultValue
+    */
+   public TimestampConverter(Object defaultValue) {
+        this.defaultValue = defaultValue;
+        this.useDefault = true;
+    }
+
+    /* (non-Javadoc)
+    * @see org.apache.commons.beanutils.Converter#convert(java.lang.Class, java.lang.Object)
+    */
+
+    @SuppressWarnings("unchecked")
+   public Object convert(Class type, Object value) {
+        Timestamp ts = (Timestamp) value;
+        String s = new String();
+        s = new SimpleDateFormat("MMM d, h:mm a").format(ts.getTime());
+        return s;
+    }
+
+    /**
+    * @param time
+    * @return
+    */
+   public String toUnixTime(Object time) {
+       Timestamp ts = (Timestamp) time;
+       Date date = new Date(ts.getTime());
+       Long seconds = date.getTime() / 1000;
+       //logger.info("unixtime: " + seconds.toString());
+       return seconds.toString();
+    }
+
+
+}

src/edu/cornell/mannlib/semservices/util/XMLGregorianCalendarConverter.java

@@ -0,0 +1,100 @@
+/*
+ * $Id: XMLGregorianCalendarConverter.java 28642 2006-10-25 13:41:54Z jdamick $
+ *
+ * Copyright 2006- Revolution Health Group.  All rights reserved.
+ *
+ * This software is the confidential and proprietary information
+ * of Revolution Health Group.  (Confidential Information).
+ * You shall not disclose such Confidential Information and shall
+ * use it only in accordance with the terms of the license
+ * agreement you entered into with Revolution Health Group.
+ *
+ */
+
+package edu.cornell.mannlib.semservices.util;
+
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import org.apache.commons.beanutils.ConversionException;
+import org.apache.commons.beanutils.Converter;
+
+public final class XMLGregorianCalendarConverter implements Converter {
+
+   // Constructors
+
+   /**
+    * Create a {@link Converter} that will throw a {@link ConversionException}
+    * if a conversion error occurs.
+    */
+   public XMLGregorianCalendarConverter() {
+      this.defaultValue = null;
+      this.useDefault = false;
+   }
+
+   /**
+    * Create a {@link Converter} that will return the specified default value if
+    * a conversion error occurs.
+    *
+    * @param defaultValue
+    *           The default value to be returned
+    */
+   public XMLGregorianCalendarConverter(Object defaultValue) {
+      this.defaultValue = defaultValue;
+      this.useDefault = true;
+   }
+
+   // Instance Variables
+
+   /**
+    * The default value specified to our Constructor, if any.
+    */
+   private Object defaultValue = null;
+
+   /**
+    * Should we return the default value on conversion errors?
+    */
+   private boolean useDefault = true;
+
+   // Public Methods
+
+   /**
+    * Convert the specified input object into an output object of the specified
+    * type.
+    *
+    * @param type
+    *  XMLGregorianCalendar type to which this value should be
+    *  converted
+    * @param value
+    *  The input value to be converted
+    *
+    * @exception ConversionException
+    *  if conversion cannot be performed successfully
+    */
+   @SuppressWarnings("unchecked")
+   public Object convert(Class type, Object value) {
+
+      if (value == null) {
+         if (useDefault) {
+            return (defaultValue);
+         } else {
+            throw new ConversionException("No value specified");
+         }
+      }
+
+      if (value instanceof XMLGregorianCalendar) {
+         return (value);
+      }
+
+      try {
+         return DatatypeFactory.newInstance().newXMLGregorianCalendar(
+               value.toString());
+      } catch (Exception e) {
+         if (useDefault) {
+            return (defaultValue);
+         } else {
+            throw new ConversionException(e);
+         }
+      }
+   }
+}

src/edu/cornell/mannlib/semservices/util/XMLUtils.java

@@ -0,0 +1,326 @@
+package edu.cornell.mannlib.semservices.util;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.io.Writer;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.xml.serialize.XMLSerializer;
+import org.w3c.dom.Document;
+import org.w3c.dom.DocumentType;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import edu.cornell.mannlib.semservices.util.MetadataNamespaceContext;
+
+/**
+ * Convenience Class to parse XML strings to DOM Document for XML contents
+ * retrieval.
+ */
+public class XMLUtils {
+    private static DocumentBuilder parser;
+    public static Writer writer;
+    static private String indent = "";
+    protected static final Log logger = LogFactory.getLog(XMLUtils.class);
+
+
+    /**
+     * @return
+     * @throws ParserConfigurationException
+     */
+    public static DocumentBuilder getDocumentBuilder()
+            throws ParserConfigurationException {
+        if (parser == null) {
+            // JPT: Remove xerces use
+            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory
+                    .newInstance();
+            documentBuilderFactory.setNamespaceAware(true);
+            documentBuilderFactory.setValidating(false);
+            parser = documentBuilderFactory.newDocumentBuilder();
+        }
+
+        return parser;
+    }
+
+    /**
+     * @param xmlString
+     * @return
+     * @throws IOException
+     * @throws SAXException
+     * @throws ParserConfigurationException
+     */
+    public synchronized static Document parse(String xmlString)
+            throws IOException, SAXException, ParserConfigurationException {
+        StringReader reader = new StringReader(xmlString);
+        InputSource inputSource = new InputSource(reader); 
+        return getDocumentBuilder().parse(inputSource);
+    }
+
+    /**
+     * @param stream
+     * @return
+     * @throws IOException
+     * @throws SAXException
+     * @throws ParserConfigurationException
+     */
+    public synchronized static Document parse(InputStream stream)
+            throws IOException, SAXException, ParserConfigurationException {
+        return getDocumentBuilder().parse(stream);
+    }
+
+    /**
+     * @param document
+     * @param name
+     * @return
+     */
+    public static String getElementByName(Document document, String name) {
+        NodeList nodes = document.getElementsByTagName(name);
+        String s = null;
+        for (int i=0; i < nodes.getLength() ; i++) {
+            Node node = nodes.item(i);
+            s = node.getTextContent().trim();
+        }
+        return s;
+    }
+
+    /**
+    * @param doc
+    * @throws IOException
+    */
+   public static void serializeDoc(Document doc) throws IOException {
+       XMLSerializer serializer = new XMLSerializer();
+       serializer.setOutputByteStream(System.out);
+       serializer.serialize(doc);
+    }
+
+    /**
+    * @param xml
+    */
+   public static void prettyPrint(String xml) {
+       Source xmlInput = new StreamSource(new StringReader(xml));
+       StreamResult xmlOutput = new StreamResult(new StringWriter());
+       Transformer transformer = null;
+      try {
+         transformer = TransformerFactory.newInstance().newTransformer();
+      } catch (TransformerConfigurationException e) {
+         // TODO Auto-generated catch block
+         e.printStackTrace();
+      } catch (TransformerFactoryConfigurationError e) {
+         // TODO Auto-generated catch block
+         e.printStackTrace();
+      }
+       //transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, "testing.dtd");
+       transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+       transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
+       try {
+         transformer.transform(xmlInput, xmlOutput);
+      } catch (TransformerException e) {
+         // TODO Auto-generated catch block
+         e.printStackTrace();
+      }
+       String formattedxml=xmlOutput.getWriter().toString();
+       System.out.println(formattedxml);
+
+    }
+
+    /**
+    * @param node
+    */
+   public static void displayNodeInfo(Node node) {
+       switch (node.getNodeType()) {
+       case Node.DOCUMENT_NODE:
+         System.out.println("Document Node ");
+         break;
+       case Node.ELEMENT_NODE:
+         System.out.println("Element Node: "+ node.getNodeName());
+         break;
+       case Node.TEXT_NODE:
+         System.out.println("Text Node: "+ node.getNodeName());
+         break;
+       case Node.CDATA_SECTION_NODE:
+         System.out.println("CDATA Section Node: ");
+         break;
+       case Node.COMMENT_NODE:
+         System.out.println("Comment Node ");
+         break;
+       case Node.PROCESSING_INSTRUCTION_NODE:
+         System.out.println("Processing Instruction Node ");
+         break;
+       case Node.ENTITY_REFERENCE_NODE:
+         System.out.println("Entity Reference Node ");
+         break;
+       case Node.DOCUMENT_TYPE_NODE:
+         System.out.println("Document Type Node ");
+         break;
+       }
+    }
+
+    /**
+    * @param node
+    * @throws IOException
+    */
+   public static void serializeNode(Node node) throws IOException {
+       if (writer == null) writer = new BufferedWriter(new OutputStreamWriter(System.out));
+
+       switch (node.getNodeType()) {
+       case Node.DOCUMENT_NODE:
+         Document doc = (Document) node;
+         writer.write("<?xml version=\"");
+         writer.write(doc.getXmlVersion());
+         writer.write("\" encoding=\"UTF-8\" standalone=\"");
+         if (doc.getXmlStandalone())
+           writer.write("yes");
+         else
+           writer.write("no");
+         writer.write("\"?>\n");
+
+         NodeList nodes = node.getChildNodes();
+         if (nodes != null)
+           for (int i = 0; i < nodes.getLength(); i++)
+             serializeNode(nodes.item(i));
+         break;
+       case Node.ELEMENT_NODE:
+         String name = node.getNodeName();
+         writer.write("<" + name);
+         NamedNodeMap attributes = node.getAttributes();
+         for (int i = 0; i < attributes.getLength(); i++) {
+           Node current = attributes.item(i);
+           writer.write(" " + current.getNodeName() + "=\"");
+           print(current.getNodeValue());
+           writer.write("\"");
+         }
+         writer.write(">");
+
+         NodeList children = node.getChildNodes();
+         if (children != null) {
+           //if ((children.item(0) != null) && (children.item(0).getNodeType() == Node.ELEMENT_NODE))
+           //  writer.write("\n");
+
+           for (int i = 0; i < children.getLength(); i++)
+             serializeNode(children.item(i));
+           if ((children.item(0) != null)
+               && (children.item(children.getLength() - 1).getNodeType() == Node.ELEMENT_NODE))
+             writer.write("");
+         }
+
+         writer.write("</" + name + ">");
+         break;
+       case Node.TEXT_NODE:
+         print(node.getNodeValue());
+         break;
+       case Node.CDATA_SECTION_NODE:
+         writer.write("CDATA");
+         print(node.getNodeValue());
+         writer.write("");
+         break;
+       case Node.COMMENT_NODE:
+         writer.write("<!-- " + node.getNodeValue() + " -->\n");
+         break;
+       case Node.PROCESSING_INSTRUCTION_NODE:
+         writer.write("<?" + node.getNodeName() + " " + node.getNodeValue() + "?>\n");
+         break;
+       case Node.ENTITY_REFERENCE_NODE:
+         writer.write("&" + node.getNodeName() + ";");
+         break;
+       case Node.DOCUMENT_TYPE_NODE:
+         DocumentType docType = (DocumentType) node;
+         String publicId = docType.getPublicId();
+         String systemId = docType.getSystemId();
+         String internalSubset = docType.getInternalSubset();
+         writer.write("<!DOCTYPE " + docType.getName());
+         if (publicId != null)
+           writer.write(" PUBLIC \"" + publicId + "\" ");
+         else
+           writer.write(" SYSTEM ");
+         writer.write("\"" + systemId + "\"");
+         if (internalSubset != null)
+           writer.write(" [" + internalSubset + "]");
+         writer.write(">\n");
+         break;
+       }
+       writer.flush();
+     }
+
+    /**
+    * @param s
+    * @throws IOException
+    */
+   private static void print(String s) throws IOException {
+       if (s == null)
+         return;
+       for (int i = 0, len = s.length(); i < len; i++) {
+         char c = s.charAt(i);
+         switch (c) {
+         case '<':
+           writer.write("&lt;");
+           break;
+         case '>':
+           writer.write("&gt;");
+           break;
+         case '&':
+           writer.write("&amp;");
+           break;
+         case '\r':
+           writer.write("&#xD;");
+           break;
+         default:
+           writer.write(c);
+         }
+       }
+     }
+
+    /**
+     * @param doc (either a Document or a Node)
+     * @param expression
+     * @return string contents
+     */
+    public static Node getNodeWithXpath(Object obj, String expression) {
+       Object root = null;
+       if (obj instanceof Document) {
+          Document doc = (Document) obj;
+          root = doc.getDocumentElement();
+       } else {
+          root = (Node) obj;
+       }
+
+        XPath xpath = XPathFactory.newInstance().newXPath();
+        xpath.setNamespaceContext(new MetadataNamespaceContext());
+        Node result = null;
+
+        try {
+            result = ((Node) xpath.evaluate(expression, root, XPathConstants.NODE));
+            return result;
+        } catch (XPathExpressionException e) {
+            logger.error("XPathExpressionException ", e);
+            return null;
+        }
+    }
+
+}

src/edu/cornell/mannlib/vitro/webapp/servlet/ConceptSearchServlet.java

@@ -2,43 +2,35 @@
 
 package edu.cornell.mannlib.vitro.webapp.servlet; 
 
-import java.io.BufferedReader;
 import java.io.IOException;
-import java.io.InputStreamReader;
+import java.io.PrintWriter;
-import java.net.URL;
+import java.util.List;
-import java.net.URLEncoder;
-import java.util.HashMap;
-import java.util.Map;
 
 import javax.servlet.ServletContext;
-import javax.servlet.ServletOutputStream;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
+import net.sf.json.JSONObject;
+
+import org.apache.commons.lang.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+
+import edu.cornell.mannlib.semservices.bo.Concept;
 import edu.cornell.mannlib.vitro.webapp.controller.VitroHttpServlet;
-import edu.cornell.mannlib.vitro.webapp.beans.Individual;
 import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
-import edu.cornell.mannlib.vitro.webapp.controller.freemarker.FreemarkerHttpServlet;
+import edu.cornell.mannlib.vitro.webapp.utils.ConceptSearchService.BeanToJsonSerializer;
-import edu.cornell.mannlib.vitro.webapp.controller.freemarker.IndividualController;
-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.utils.ConceptSearchService.ConceptSearchServiceUtils;
-import edu.cornell.mannlib.vitro.webapp.web.templatemodels.individual.IndividualTemplateModel;
-import freemarker.ext.beans.BeansWrapper;
-import freemarker.template.DefaultObjectWrapper;
 
 public class ConceptSearchServlet extends VitroHttpServlet {
     
     private static final long serialVersionUID = 1L;
-    private static final Log log = LogFactory.getLog(UMLSTerminologyAnnotation.class);
+    private static final Log log = LogFactory.getLog(ConceptSearchServlet.class);
     
     @Override
     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-        super.doPost(req, resp);
+        super.doGet(req, resp);
     }
 
     @Override
@@ -48,23 +40,26 @@ public class ConceptSearchServlet extends VitroHttpServlet {
 
         try{
         	ServletContext ctx = vreq.getSession().getServletContext();
-        	String results = ConceptSearchServiceUtils.getSearchResults(ctx, vreq);
+        	//Json output should be written out
-        	
+        	List<Concept> results = ConceptSearchServiceUtils.getSearchResults(ctx, vreq);
-        	try{
+        	String json = renderJson(results);
-	            ServletOutputStream sos = resp.getOutputStream();
+        	json = StringUtils.replaceChars(json, "\r\t\n", "");
-
+            PrintWriter writer = resp.getWriter();
-	    		resp.setCharacterEncoding("UTF-8");
+            resp.setContentType("application/json");
-	            resp.setContentType("application/json;charset=UTF-8");
+            writer.write(json);
-	    		
+            writer.close();
-	            sos.print(results);
-
-	    	} catch(Exception ex) {
-	    		log.error("error occurred in servlet", ex);
-	    	}
         	
         }catch(Exception ex){
             log.warn(ex,ex);            
         }        
     }
     
+    protected String renderJson(List<Concept> conceptList) {
+
+        JSONObject jsonObject = null;
+        jsonObject = BeanToJsonSerializer.serializeToJsonObject(conceptList);
+        log.debug(jsonObject.toString());
+        return jsonObject.toString();
+    }
+
 }

src/edu/cornell/mannlib/vitro/webapp/utils/ConceptSearchService/BeanToJsonSerializer.java

@@ -0,0 +1,226 @@
+/*
+ * $Id: BeanToJsonSerializer.java 66350 2007-08-20 21:11:41Z xluan $
+ *
+ * Copyright 2006- Revolution Health Group.  All rights reserved.
+ *
+ * This software is the confidential and proprietary information
+ * of Revolution Health Group.  (Confidential Information).
+ * You shall not disclose such Confidential Information and shall
+ * use it only in accordance with the terms of the license
+ * agreement you entered into with Revolution Health Group.
+ *
+ */
+package edu.cornell.mannlib.vitro.webapp.utils.ConceptSearchService;
+
+import java.beans.PropertyDescriptor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import org.apache.commons.beanutils.ConvertUtils;
+import org.apache.commons.beanutils.PropertyUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import net.sf.json.JSONArray;
+import net.sf.json.JSONException;
+import net.sf.json.JSONNull;
+import net.sf.json.JSONObject;
+
+import edu.cornell.mannlib.semservices.bo.Day;
+import edu.cornell.mannlib.semservices.bo.Time;
+import edu.cornell.mannlib.semservices.util.ClassUtils;
+import edu.cornell.mannlib.semservices.util.DateConverter;
+import edu.cornell.mannlib.semservices.util.DayConverter;
+import edu.cornell.mannlib.semservices.util.ObjectUtils;
+import edu.cornell.mannlib.semservices.util.TimeConverter;
+import edu.cornell.mannlib.semservices.util.TimestampConverter;
+
+@SuppressWarnings("serial")
+public class BeanToJsonSerializer {
+   private static final Log logger = LogFactory.getLog(BeanToJsonSerializer.class);
+
+   /**
+    *
+    */
+   private BeanToJsonSerializer() {
+      ConvertUtils.register(new DateConverter(), java.util.Date.class);
+      ConvertUtils.register(new TimestampConverter(),
+            String.class);
+      ConvertUtils.register(new TimeConverter(), String.class);
+      ConvertUtils.register(new DayConverter(), String.class);
+   }
+
+   /**
+    *
+    */
+   @SuppressWarnings("unchecked")
+   private static final Set<Class> CONVERTABLE_CLASSES = new HashSet<Class>() {
+      {
+         add(XMLGregorianCalendar.class);
+      }
+   };
+
+   /**
+    * @param bean
+    * @return
+    */
+   public static JSONObject serializeToJsonObject(Object bean) {
+      Object result = serialize(bean);
+      JSONObject jsonObj = new JSONObject();
+      try {
+         if (ObjectUtils.isArray(bean) || result instanceof JSONArray) {
+            jsonObj.put("array", result);
+         } else if (result instanceof JSONObject) {
+            jsonObj = (JSONObject) result;
+         } else {
+            jsonObj.put(bean.getClass().getSimpleName(), result);
+         }
+      } catch (JSONException e) {
+         logger.error("JSONException ",e);
+      }
+      return jsonObj;
+   }
+
+   /**
+    * @param bean
+    * @return
+    */
+   @SuppressWarnings("unchecked")
+   public static Object serialize(Object bean) {
+      //String simpleName = bean.getClass().getSimpleName();
+      Object result = JSONNull.getInstance();
+
+      if (isObjectJson(bean)) {
+         result = bean;
+      } else if (bean != null && isConvertable(bean.getClass())) {
+         //logger.info("Converting convertable Class: "+simpleName);
+         result = ConvertUtils.convert(bean);
+      } else if (bean != null && Time.class.isAssignableFrom(bean.getClass())) {
+         //logger.info("Converting Time Class: "+simpleName);
+         result = TimeConverter.toUnixTime((Time) bean);
+      } else if (bean != null && Day.class.isAssignableFrom(bean.getClass())) {
+         //logger.info("Converting Day Class: "+simpleName);
+         result = DayConverter.toUnixTime((Day) bean);
+      } else if (bean != null
+            && java.util.Date.class.isAssignableFrom(bean.getClass())) {
+         // for date consistency, use the XMLGregorianCalendar
+         // result =
+         // DateConverter.toXMLGregorianCalendar((java.util.Date)bean
+         // ).toString();
+         //logger.info("Converting Date Class: "+simpleName);
+         result = DateConverter.toFormattedString((java.util.Date) bean);
+      } else if (bean != null && ObjectUtils.isComplex(bean)
+            && !ObjectUtils.isArray(bean) && !ObjectUtils.isMap(bean)) {
+         //logger.info("Converting complex bean: "+simpleName);
+         JSONObject jsonObject = new JSONObject();
+         try {
+            PropertyDescriptor[] pds = PropertyUtils
+                  .getPropertyDescriptors(bean);
+            for (int i = 0; i < pds.length; i++) {
+               String key = pds[i].getName();
+               if ("class".equals(key)) {
+                  continue;
+               }
+
+               Class type = pds[i].getPropertyType();
+               Object value = PropertyUtils.getProperty(bean, key);
+
+               if (String.class.isAssignableFrom(type)) {
+                  jsonObject.put(key, (value == null) ? "" : value);
+               } else if (ObjectUtils.isArray(value)) {
+                  jsonObject.put(key, serialize(value));
+               } else if (value == null) {
+                  jsonObject.put(key, JSONNull.getInstance());
+               } else if (ObjectUtils.isSimpleType(value) || type.isEnum()) {
+                  if (ClassUtils.isXmlEnum(type)) {
+                     jsonObject.put(key, ObjectUtils.getXmlEnumValue(value));
+                  } else {
+                     jsonObject.put(key, value);
+                  }
+               } else {
+                  jsonObject.put(key, serialize(value));
+               }
+            }
+
+            result = jsonObject;
+         } catch (IllegalAccessException e) {
+            logger.error("IllegalAccessException ", e);
+         } catch (InvocationTargetException e) {
+            logger.error("InvocationTargetException ", e);
+         } catch (NoSuchMethodException e) {
+            logger.error("NoSuchMethodException ", e);
+         } catch (JSONException e) {
+            logger.error("JSONException ", e);
+         }
+      } else if (ObjectUtils.isArray(bean)) {
+         //logger.info("Converting Array bean: "+simpleName);
+         Collection collection = null;
+         if (bean.getClass().isArray()) {
+            collection = Arrays.asList((Object[]) bean);
+         } else {
+            collection = (Collection) bean;
+         }
+
+         result = new JSONArray();
+         for (Object item : collection) {
+            ((JSONArray) result).add(serialize(item));
+         }
+      } else if (ObjectUtils.isMap(bean)) {
+         //logger.info("Converting Map bean: "+simpleName);
+         Map map = (Map) bean;
+         result = new JSONObject();
+         for (Object key : map.keySet()) {
+            try {
+               ((JSONObject) result).put(key.toString(),
+                     serialize(map.get(key)));
+            } catch (JSONException e) {
+               logger.error("JSONException ",e);
+            }
+         }
+      } else if (bean != null && ClassUtils.isXmlEnum(bean.getClass())) {
+         //logger.info("converting xmlEnum bean: "+simpleName);
+         result = ObjectUtils.getXmlEnumValue(bean);
+      } else {
+         //logger.info("just returning the bean: "+simpleName);
+         result = bean;
+      }
+      return result;
+   }
+
+   /**
+    * @param clazz
+    * @return
+    */
+   @SuppressWarnings("unchecked")
+   private static boolean isConvertable(Class clazz) {
+      boolean found = false;
+      for (Class convertableClass : CONVERTABLE_CLASSES) {
+         if (convertableClass.isAssignableFrom(clazz)) {
+            found = true;
+            break;
+         } else {
+            //logger.warn("Class is not convertable");
+            //logger.warn("Class: " + clazz.getSimpleName());
+         }
+      }
+      return found;
+   }
+
+   /**
+    * @param bean
+    * @return
+    */
+   private static boolean isObjectJson(Object bean) {
+      if ((JSONNull.getInstance().equals(bean)) || (bean instanceof JSONObject)
+            || (bean instanceof JSONArray)) {
+         return true;
+      }
+      return false;
+   }
+}

src/edu/cornell/mannlib/vitro/webapp/utils/ConceptSearchService/ConceptSearchServiceUtils.java

@@ -2,43 +2,19 @@
 
 package edu.cornell.mannlib.vitro.webapp.utils.ConceptSearchService;
 
-import java.net.URLEncoder;
-import java.util.ArrayList;
 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 com.hp.hpl.jena.ontology.OntModel;
+import edu.cornell.mannlib.semservices.bo.Concept;
-import com.hp.hpl.jena.rdf.model.Model;
+import edu.cornell.mannlib.semservices.service.ExternalConceptService;
-import com.hp.hpl.jena.rdf.model.RDFNode;
-import com.hp.hpl.jena.rdf.model.ResourceFactory;
-import com.hp.hpl.jena.rdf.model.Statement;
-import com.hp.hpl.jena.rdf.model.StmtIterator;
-
-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.dao.DisplayVocabulary;
-import edu.cornell.mannlib.vitro.webapp.dao.PageDao;
-import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
-import edu.cornell.mannlib.vitro.webapp.dao.jena.VClassGroupCache;
-import edu.cornell.mannlib.vitro.webapp.web.templatemodels.VClassGroupTemplateModel;
-import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
-import edu.cornell.mannlib.vitro.webapp.edit.n3editing.configuration.generators.EditConfigurationGenerator;
-
 /**
- * This will pass these variables to the template:
+ * Utilities for search    
- * classGroupUri: uri of the classgroup associated with this page.
- * vClassGroup: a data structure that is the classgroup associated with this page.     
  */
 public class ConceptSearchServiceUtils {
     private static final Log log = LogFactory.getLog(ConceptSearchServiceUtils.class);
@@ -53,27 +29,37 @@ public class ConceptSearchServiceUtils {
 		return null;
 	}
 	
+	//Get the URLS for the different services
+	//URL to label
+	public static HashMap<String, String> getVocabSources() {
+		HashMap<String, String> map = new HashMap<String, String>();
+    	map.put("http://link.informatics.stonybrook.edu/umls/", "UMLS");
+    	map.put("http://www.fao.org/webservices/Agrovoc", "Agrovoc");
+    	return map;
+	}
+	
 	
     
     //Get the hashmap mapping service name to Service class
     private static HashMap<String, String> getMapping() {
     	HashMap<String, String> map = new HashMap<String, String>();
-    	map.put("UMLS", "edu.cornell.mannlib.vitro.webapp.utils.ConceptSearchService.UMLSConceptSearch");
+    	map.put("http://link.informatics.stonybrook.edu/umls/", "edu.cornell.mannlib.semservices.service.impl.UMLSService");
+    	map.put("http://www.fao.org/webservices/Agrovoc", "edu.cornell.mannlib.semservices.service.impl.AgrovocService");
+
     	return map;
     }
     
-    public static String getSearchResults(ServletContext context, VitroRequest vreq) {
+    public static List<Concept> getSearchResults(ServletContext context, VitroRequest vreq) {
-    	String searchServiceName = getSearchServiceName(vreq);
+    	String searchServiceName = getSearchServiceUri(vreq);
-    
     	String searchServiceClassName = getConceptSearchServiceClassName(searchServiceName);
     
-    	ConceptSearchInterface conceptSearchClass = null;
+    	ExternalConceptService conceptServiceClass = null;
 	
 	    Object object = null;
 	    try {
 	        Class classDefinition = Class.forName(searchServiceClassName);
 	        object = classDefinition.newInstance();
-	        conceptSearchClass = (ConceptSearchInterface) object;
+	        conceptServiceClass = (ExternalConceptService) object;
 	    } catch (InstantiationException e) {
 	        System.out.println(e);
 	    } catch (IllegalAccessException e) {
@@ -82,16 +68,23 @@ public class ConceptSearchServiceUtils {
 	        System.out.println(e);
 	    }    	
     
-	    if(conceptSearchClass == null){
+	    if(conceptServiceClass == null){
 	    	log.error("could not find Concept Search Class for " + searchServiceName);
 	    	return null;
 	    } 
-	    return conceptSearchClass.doSearch(context, vreq);
+	    
+	    //Get search
+	    String searchTerm = getSearchTerm(vreq);
+	    List<Concept> conceptResults =  conceptServiceClass.processResults(searchTerm);
+	    return conceptResults;
     }
 
 
+	private static String getSearchServiceUri(VitroRequest vreq) {
+		return vreq.getParameter("source");
+	}
 
-	private static String getSearchServiceName(VitroRequest vreq) {
+	private static String getSearchTerm(VitroRequest vreq) {
-		return vreq.getParameter("searchServiceName");
+		return vreq.getParameter("searchTerm");
 	}
 }