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

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

Browse source
This commit is contained in:
hjkhjk54 2011-11-30 18:41:57 +00:00
parent 943315a9c6
commit ce84967d01
28 changed files with 3472 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
lib/agrovoc_ws.jar Normal file
View file

Binary file not shown.

BIN
lib/axis.jar Normal file
View file

Binary file not shown.

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

Binary file not shown.

BIN
lib/commons-discovery-0.2.jar Normal file
View file

Binary file not shown.

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

Binary file not shown.

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

Binary file not shown.

BIN
lib/webserviceutils.jar Normal file
View file

Binary file not shown.

3
productMods/edit/forms/js/addConcept.js
View file

@ -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");

4
productMods/templates/freemarker/edit/forms/addAssociatedConcept.ftl
View file

@ -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>

104
src/edu/cornell/mannlib/semservices/bo/Concept.java Normal file
View file

@ -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;
}
}

749
src/edu/cornell/mannlib/semservices/bo/Day.java Normal file
View file

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

257
src/edu/cornell/mannlib/semservices/bo/Time.java Normal file
View file

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

11
src/edu/cornell/mannlib/semservices/service/ExternalConceptService.java Normal file
View file

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

494
src/edu/cornell/mannlib/semservices/service/impl/AgrovocService.java Normal file
View file

@ -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;
}
}

152
src/edu/cornell/mannlib/semservices/service/impl/UMLSService.java Normal file
View file

@ -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("");
}
}
}

152
src/edu/cornell/mannlib/semservices/util/ClassUtils.java Normal file
View file

@ -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;
}
}

141
src/edu/cornell/mannlib/semservices/util/DateConverter.java Normal file
View file

@ -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;
}
}

195
src/edu/cornell/mannlib/semservices/util/DateUtils.java Normal file
View file

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

78
src/edu/cornell/mannlib/semservices/util/DayConverter.java Normal file
View file

@ -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();
}
}

24
src/edu/cornell/mannlib/semservices/util/MetadataNamespaceContext.java Normal file
View file

@ -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();
}
}

268
src/edu/cornell/mannlib/semservices/util/ObjectUtils.java Normal file
View file

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

72
src/edu/cornell/mannlib/semservices/util/TimeConverter.java Normal file
View file

@ -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();
}
}

63
src/edu/cornell/mannlib/semservices/util/TimestampConverter.java Normal file
View file

@ -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();
}
}

100
src/edu/cornell/mannlib/semservices/util/XMLGregorianCalendarConverter.java Normal file
View file

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

326
src/edu/cornell/mannlib/semservices/util/XMLUtils.java Normal file
View file

@ -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;
}
}
}

57
src/edu/cornell/mannlib/vitro/webapp/servlet/ConceptSearchServlet.java
View file

@ -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.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;
import java.io.PrintWriter;
import java.util.List;
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.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.BeanToJsonSerializer;
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);
try{
ServletOutputStream sos = resp.getOutputStream();
resp.setCharacterEncoding("UTF-8");
resp.setContentType("application/json;charset=UTF-8");
sos.print(results);
} catch(Exception ex) {
log.error("error occurred in servlet", ex);
}
//Json output should be written out
List<Concept> results = ConceptSearchServiceUtils.getSearchResults(ctx, vreq);
String json = renderJson(results);
json = StringUtils.replaceChars(json, "\r\t\n", "");
PrintWriter writer = resp.getWriter();
resp.setContentType("application/json");
writer.write(json);
writer.close();
}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();
}
}

226
src/edu/cornell/mannlib/vitro/webapp/utils/ConceptSearchService/BeanToJsonSerializer.java Normal file
View file

@ -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;
}
}

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

@ -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 com.hp.hpl.jena.rdf.model.Model;
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.semservices.bo.Concept;
import edu.cornell.mannlib.semservices.service.ExternalConceptService;
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:
* classGroupUri: uri of the classgroup associated with this page.
* vClassGroup: a data structure that is the classgroup associated with this page.
* Utilities for search
*/
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) {
String searchServiceName = getSearchServiceName(vreq);
public static List<Concept> getSearchResults(ServletContext context, VitroRequest 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) {
return vreq.getParameter("searchServiceName");
private static String getSearchTerm(VitroRequest vreq) {
return vreq.getParameter("searchTerm");
}
}