diff --git a/src/java/hibernate.cfg.xml b/src/java/hibernate.cfg.xml new file mode 100644 index 0000000..3e77d50 --- /dev/null +++ b/src/java/hibernate.cfg.xml @@ -0,0 +1,40 @@ + + + + + + + + java:comp/env/jdbc/lex-datasource + true + false + net.sf.hibernate.dialect.MySQLDialect + + + + + + + diff --git a/src/java/log4j.properties b/src/java/log4j.properties new file mode 100644 index 0000000..3e77d50 --- /dev/null +++ b/src/java/log4j.properties @@ -0,0 +1,40 @@ + + + + + + + + java:comp/env/jdbc/lex-datasource + true + false + net.sf.hibernate.dialect.MySQLDialect + + + + + + + diff --git a/src/java/org/thdl/lex/AuthenticationFilter.java b/src/java/org/thdl/lex/AuthenticationFilter.java new file mode 100644 index 0000000..7b09230 --- /dev/null +++ b/src/java/org/thdl/lex/AuthenticationFilter.java @@ -0,0 +1,92 @@ +package org.thdl.lex; + +import org.thdl.users.*; + +import javax.servlet.Filter; +import javax.servlet.FilterChain; +import javax.servlet.FilterConfig; +import javax.servlet.ServletRequest; +import javax.servlet.ServletResponse; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; +import javax.servlet.ServletException; +import java.io.IOException; +import java.util.Enumeration; + +public class AuthenticationFilter implements Filter +{ +//attributes + private String loginPage; + private UserSessionManager sessionMgr; + +//accessors + public void setLoginPage(String loginPage) { + this.loginPage = loginPage; + } + public String getLoginPage() { + return loginPage; + } + public void setSessionMgr() { + this.sessionMgr = UserSessionManager.getInstance(); + } + public UserSessionManager getSessionMgr() { + return sessionMgr; + } + +//contract methods + public void init(FilterConfig config) throws ServletException + { + setSessionMgr(); + setLoginPage( config.getInitParameter("loginPage") ); + if ( null == getLoginPage() ) + throw new ServletException("The loginPage parameter must be specified"); + } + public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException + { + if ( request instanceof HttpServletRequest && response instanceof HttpServletResponse) + { + HttpServletRequest req = (HttpServletRequest) request; + HttpSession session = req.getSession(true); + ThdlUser user = sessionMgr.getSessionUser(session); + if (null == user ) + { + requireLogin(req, (HttpServletResponse)response, session); + } + else + { + chain.doFilter(request, response); + } + } + else + { + throw new ServletException("Filter only applicable to HTTP and HTTPS requests"); + } + } + public void destroy() {} +//helper methods + public void requireLogin(HttpServletRequest request, HttpServletResponse response, HttpSession session) throws IOException + { + StringBuffer buffer = request.getRequestURL(); + String query = request.getQueryString(); + Enumeration params = request.getParameterNames(); + boolean paramsExist; + if ( params.hasMoreElements() ) + { + paramsExist=true; + buffer.append('?'); + while ( params.hasMoreElements() ) + { + String temp = (String)params.nextElement(); + buffer.append( temp + "=" +request.getParameter( temp ) ); + if ( params.hasMoreElements() ) + buffer.append("&"); + } + } + else + paramsExist=false; + + sessionMgr.setSessionLoginTarget( session, buffer.toString() ); + UserSessionManager.doRedirect(request, response, loginPage); + } +} diff --git a/src/java/org/thdl/lex/GuestFilter.java b/src/java/org/thdl/lex/GuestFilter.java new file mode 100644 index 0000000..5432b6c --- /dev/null +++ b/src/java/org/thdl/lex/GuestFilter.java @@ -0,0 +1,72 @@ +package org.thdl.lex; + +import org.thdl.users.*; + +import javax.servlet.Filter; +import javax.servlet.FilterChain; +import javax.servlet.FilterConfig; +import javax.servlet.ServletRequest; +import javax.servlet.ServletResponse; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; +import javax.servlet.ServletException; +import java.io.IOException; +import java.util.Enumeration; + +public class GuestFilter implements Filter +{ +//attributes + private String loginPage; + private UserSessionManager sessionMgr; + +//accessors + public void setLoginPage(String loginPage) { + this.loginPage = loginPage; + } + public String getLoginPage() { + return loginPage; + } + public void setSessionMgr() { + this.sessionMgr = UserSessionManager.getInstance(); + } + public UserSessionManager getSessionMgr() { + return sessionMgr; + } + +//contract methods + public void init(FilterConfig config) throws ServletException + { + setSessionMgr(); + } + public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException + { + if ( request instanceof HttpServletRequest && response instanceof HttpServletResponse) + { + HttpServletRequest req = (HttpServletRequest) request; + HttpSession session = req.getSession(true); + ThdlUser user = getSessionMgr().getSessionUser(session); + if (null == user ) + { + try + { + user = new LexUser(); + } + catch ( Exception e ) + { + throw new ServletException( e ); + } + user.setRoles( "guest" ); + getSessionMgr().setSessionUser( session, user ); + getSessionMgr().setDisplayMode( session, "full" ); + } + chain.doFilter(request, response); + } + else + { + throw new ServletException("Filter only applicable to HTTP and HTTPS requests"); + } + } + public void destroy() {} +//helper methods +} diff --git a/src/java/org/thdl/lex/HibernateSession.java b/src/java/org/thdl/lex/HibernateSession.java new file mode 100644 index 0000000..2c59138 --- /dev/null +++ b/src/java/org/thdl/lex/HibernateSession.java @@ -0,0 +1,70 @@ +package org.thdl.lex; + +import net.sf.hibernate.*; +import net.sf.hibernate.cfg.*; + + +/** + * Description of the Class + * + *@author Hibernate WIKI + *@created October 1, 2003 + */ +public class HibernateSession +{ + + private static SessionFactory sessionFactory; + public final static ThreadLocal session = new ThreadLocal(); + + + /** + * Description of the Method + * + *@return Description of the Returned Value + *@exception HibernateException Description of Exception + *@since + */ + public static Session currentSession() + throws HibernateException + { + + Session s = (Session) session.get(); + if ( s == null ) + { + + // Don't get from JNDI, use a static SessionFactory + if ( sessionFactory == null ) + { + + // Use default hibernate.cfg.xml + sessionFactory = new Configuration().configure().buildSessionFactory(); + + } + + s = sessionFactory.openSession(); + session.set( s ); + } + return s; + } + + + /** + * Description of the Method + * + *@exception HibernateException Description of Exception + *@since + */ + public static void closeSession() + throws HibernateException + { + + Session s = (Session) session.get(); + session.set( null ); + if ( s != null ) + { + s.close(); + } + } + +} + diff --git a/src/java/org/thdl/lex/HibernateTestServlet.java b/src/java/org/thdl/lex/HibernateTestServlet.java new file mode 100644 index 0000000..eb44f0f --- /dev/null +++ b/src/java/org/thdl/lex/HibernateTestServlet.java @@ -0,0 +1,262 @@ +package org.thdl.lex; + +import org.thdl.lex.component.*; +// import org.thdl.lex.component.peers.*; + +import net.sf.hibernate.*; +import net.sf.hibernate.cfg.*; +// import net.sf.hibernate.tool.hbm2ddl.*; + +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.ServletException; +import java.sql.*; +import java.util.*; +import java.io.IOException; +import java.io.PrintWriter; + + +/** + * Description of the Class + * + *@author travis + *@created October 1, 2003 + */ +public class HibernateTestServlet + extends HttpServlet +{ + + private SessionFactory sessionFactory; + private Session session; + private Transaction transaction; + + + /** + * Sets the sessionFactory attribute of the HibernateTestServlet object + * + *@param sessionFactory The new sessionFactory value + *@since + */ + public void setSessionFactory( SessionFactory sessionFactory ) + { + this.sessionFactory = sessionFactory; + } + + + /** + * Sets the session attribute of the HibernateTestServlet object + * + *@param session The new session value + *@since + */ + public void setSession( Session session ) + { + this.session = session; + } + + + /** + * Sets the transaction attribute of the HibernateTestServlet object + * + *@param transaction The new transaction value + *@since + */ + public void setTransaction( Transaction transaction ) + { + this.transaction = transaction; + } + + + /** + * Gets the sessionFactory attribute of the HibernateTestServlet object + * + *@return The sessionFactory value + *@since + */ + public SessionFactory getSessionFactory() + { + return sessionFactory; + } + + + /** + * Gets the session attribute of the HibernateTestServlet object + * + *@return The session value + *@since + */ + public Session getSession() + { + return session; + } + + + /** + * Gets the transaction attribute of the HibernateTestServlet object + * + *@return The transaction value + *@since + */ + public Transaction getTransaction() + { + return transaction; + } + + + /** + * Description of the Method + * + *@param request Description of Parameter + *@param response Description of Parameter + *@exception ServletException Description of Exception + *@exception IOException Description of Exception + *@since + */ + public void doGet( HttpServletRequest request, HttpServletResponse response ) + throws ServletException, IOException + { + + try + { + initHibernate(); + + response.setContentType( "text/html" ); + PrintWriter out = response.getWriter(); + out.println( "" ); + + beginTransaction(); + processMods( out ); + //testQuery( out ); + endTransaction( false ); + + out.println( "" ); + + } + catch ( SQLException e ) + { + try + { + getSession().close(); + throw new ServletException( e ); + } + catch ( HibernateException he ) + { + throw new ServletException( he ); + } + } + catch ( HibernateException e ) + { + try + { + getSession().close(); + throw new ServletException( e ); + } + catch ( HibernateException he ) + { + throw new ServletException( he ); + } + } + + } + + + // Helper Methods + /** + * Description of the Method + * + *@exception HibernateException Description of Exception + *@since + */ + private void initHibernate() + throws HibernateException + { + + // Load Configuration and build SessionFactory + setSessionFactory( new Configuration().configure().buildSessionFactory() ); + } + + + /** + * Description of the Method + * + *@exception HibernateException Description of Exception + *@since + */ + private void beginTransaction() + throws HibernateException + { + setSession( getSessionFactory().openSession() ); + setTransaction( session.beginTransaction() ); + } + + + /** + * Description of the Method + * + *@param commit Description of Parameter + *@exception HibernateException Description of Exception + *@since + */ + private void endTransaction( boolean commit ) + throws HibernateException + { + + if ( commit ) + { + getTransaction().commit(); + } + else + { + // Don't commit the transaction, can be faster for read-only operations + getTransaction().rollback(); + } + getSession().close(); + } + + + /** + * Description of the Method + * + *@param out Description of Parameter + *@exception SQLException Description of Exception + *@exception HibernateException Description of Exception + *@since + */ + public void processMods( PrintWriter out ) throws SQLException, HibernateException + { + String queryString = "FROM org.thdl.lex.component.LexComponent"; + Query query = getSession().createQuery( queryString ); + + out.println( "Starting..." ); + for ( Iterator it = query.iterate(); it.hasNext(); ) + { + ILexComponent lc = (ILexComponent) it.next(); + out.println( lc.getMetaId() + "
" ); + } + } + + + /** + * A unit test for JUnit + * + *@param out Description of Parameter + *@exception SQLException Description of Exception + *@exception HibernateException Description of Exception + *@since + */ + public void testQuery( PrintWriter out ) + throws SQLException, HibernateException + { + String queryString = "FROM org.thdl.lex.component.Term as term WHERE term.term = :term"; + Query query = getSession().createQuery( queryString ); + ITerm term = new Term(); + term.setTerm( "thos pa" ); + query.setProperties( term ); + for ( Iterator it = query.iterate(); it.hasNext(); ) + { + out.println( it.next() ); + } + } +} + diff --git a/src/java/org/thdl/lex/LexActionServlet.java b/src/java/org/thdl/lex/LexActionServlet.java new file mode 100644 index 0000000..b606aee --- /dev/null +++ b/src/java/org/thdl/lex/LexActionServlet.java @@ -0,0 +1,207 @@ +package org.thdl.lex; + +import org.thdl.lex.component.*; +import org.thdl.lex.commands.*; + +import java.io.IOException; +import javax.servlet.ServletConfig; +import javax.servlet.ServletException; +import javax.servlet.RequestDispatcher; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.util.HashMap; + + +/** + * Description of the Class + * + *@author travis + *@created October 1, 2003 + */ +public class LexActionServlet extends HttpServlet +{ +//attributes + private HashMap commands; + private String cmd; + + +//accessors + + /** + * Sets the commands attribute of the LexActionServlet object + * + *@param commands The new commands value + *@since + */ + public void setCommands( HashMap commands ) + { + this.commands = commands; + } + + + /** + * Sets the cmd attribute of the LexActionServlet object + * + *@param cmd The new cmd value + *@since + */ + public void setCmd( String cmd ) + { + this.cmd = cmd; + } + + + /** + * Gets the commands attribute of the LexActionServlet object + * + *@return The commands value + *@since + */ + public HashMap getCommands() + { + return commands; + } + + + /** + * Gets the cmd attribute of the LexActionServlet object + * + *@return The cmd value + *@since + */ + public String getCmd() + { + return cmd; + } + + +//helper methods + + /** + * Description of the Method + * + *@param config Description of Parameter + *@exception ServletException Description of Exception + *@since + */ + public void init( ServletConfig config ) throws ServletException + { + super.init( config ); + initCommands(); + config.getServletContext().setAttribute( "flatData", new LexFlatDataRepository() ); + } + + + /** + * Description of the Method + * + *@param req Description of Parameter + *@param res Description of Parameter + *@exception ServletException Description of Exception + *@exception IOException Description of Exception + *@since + */ + public void service( HttpServletRequest req, HttpServletResponse res ) throws ServletException, IOException + { + String next; + try + { + setCmd( req.getParameter( LexConstants.COMMAND_REQ_PARAM ) ); + Command command = lookupCommand( getCmd() ); + LexComponent component = (LexComponent) req.getAttribute( LexConstants.COMPONENT_REQ_ATTR ); + next = command.execute( req, component ); + CommandToken.set( req ); + } + catch ( CommandException e ) + { + req.setAttribute( "javax.servlet.jsp.jspException", e ); + next = LexConstants.ERROR_PAGE; + try + { + LexComponentRepository.cleanup(); + } + catch ( LexRepositoryException lre ) + { + Exception ex = new Exception( "LexComponentRepository couldn't clean up after Exception because: " + lre.getMessage(), e ); + req.setAttribute( "javax.servlet.jsp.jspException", ex ); + } + } + catch ( Exception e ) + { + req.setAttribute( "javax.servlet.jsp.jspException", e ); + next = LexConstants.ERROR_PAGE; + try + { + LexComponentRepository.cleanup(); + } + catch ( LexRepositoryException lre ) + { + Exception ex = new Exception( "LexComponentRepository couldn't clean up after Exception because: " + lre.getMessage(), e ); + req.setAttribute( "javax.servlet.jsp.jspException", ex ); + } + } + RequestDispatcher rd; + rd = getServletContext().getRequestDispatcher( LexConstants.JSP_DIR + next ); + rd.forward( req, res ); + } + + + /** + * Description of the Method + * + *@param cmdKey Description of Parameter + *@return Description of the Returned Value + *@exception CommandException Description of Exception + *@since + */ + private Command lookupCommand( String cmdKey ) throws CommandException + { + if ( cmdKey == null ) + { + cmdKey = "menu"; + } + if ( getCommands().containsKey( cmdKey ) ) + { + return (Command) getCommands().get( cmdKey ); + } + else + { + throw new CommandException( "Invalid Command Identifier: '" + getCmd() + "'" ); + } + } + + + /** + * Description of the Method + * + *@since + */ + private void initCommands() + { + HashMap commands = new HashMap(); + commands.put( "menu", new NullCommand( "menu.jsp" ) ); + commands.put( "abort", new AbortCommand( "menu.jsp" ) ); + commands.put( "testing", new TestingCommand( "displayEntry.jsp" ) ); + // commands.put( "login", new NullCommand( "login.jsp" ) ); + commands.put( "logout", new NullCommand( "logout.jsp" ) ); + commands.put( "new", new NewComponentCommand() ); + commands.put( "find", new FindCommand() ); + commands.put( "getInsertForm", new GetInsertFormCommand( "displayForm.jsp?formMode=insert" ) ); + commands.put( "getUpdateForm", new GetUpdateFormCommand( "displayForm.jsp?formMode=update" ) ); + commands.put( "getTranslationForm", new GetTranslationFormCommand( "displayForm.jsp?formMode=insert" ) ); + commands.put( "annotate", new GetInsertFormCommand( "displayForm.jsp?formMode=insert" ) ); + commands.put( "insert", new InsertCommand( "displayEntry.jsp" ) ); + commands.put( "update", new UpdateCommand( "displayEntry.jsp" ) ); + commands.put( "display", new DisplayCommand() ); + commands.put( "displayFull", new DisplayCommand() ); + commands.put( "editEntry", new DisplayCommand() ); + commands.put( "remove", new RemoveCommand() ); + commands.put( "getMetaPrefsForm", new NullCommand( "metaPrefsForm.jsp" ) ); + commands.put( "getMetaDefaultsForm", new NullCommand( "metaDefaultsForm.jsp" ) ); + commands.put( "setMetaPrefs", new PreferencesCommand( "menu.jsp" ) ); + commands.put( "setMetaDefaults", new PreferencesCommand( "menu.jsp" ) ); + setCommands( commands ); + } +} + diff --git a/src/java/org/thdl/lex/LexComponentFilter.java b/src/java/org/thdl/lex/LexComponentFilter.java new file mode 100644 index 0000000..1b09d9e --- /dev/null +++ b/src/java/org/thdl/lex/LexComponentFilter.java @@ -0,0 +1,206 @@ +package org.thdl.lex; + +import org.thdl.lex.component.*; + +import javax.servlet.Filter; +import javax.servlet.FilterChain; +import javax.servlet.FilterConfig; +import javax.servlet.ServletRequest; +import javax.servlet.ServletResponse; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; +import javax.servlet.ServletException; +import java.io.IOException; +import java.util.HashMap; + + +/** + * Description of the Class + * + *@author travis + *@created October 1, 2003 + */ +public class LexComponentFilter implements Filter +{ +//attributes + private HashMap blanks; + private UserSessionManager sessionMgr; + + +//accessors + /** + * Sets the blanks attribute of the LexComponentFilter object + * + *@param blanks The new blanks value + *@since + */ + public void setBlanks( HashMap blanks ) + { + this.blanks = blanks; + } + + + /** + * Sets the sessionMgr attribute of the LexComponentFilter object + * + *@param sessionMgr The new sessionMgr value + *@since + */ + public void setSessionMgr( UserSessionManager sessionMgr ) + { + this.sessionMgr = sessionMgr; + } + + + /** + * Gets the blanks attribute of the LexComponentFilter object + * + *@return The blanks value + *@since + */ + public HashMap getBlanks() + { + return blanks; + } + + + /** + * Gets the sessionMgr attribute of the LexComponentFilter object + * + *@return The sessionMgr value + *@since + */ + public UserSessionManager getSessionMgr() + { + if ( null == sessionMgr ) + { + setSessionMgr( UserSessionManager.getInstance() ); + } + return sessionMgr; + } + + +//contract methods + + /** + * Description of the Method + * + *@param config Description of Parameter + *@exception ServletException Description of Exception + *@since + */ + public void init( FilterConfig config ) throws ServletException + { + try + { + setBlanks( new HashMap() ); + getBlanks().put( LexConstants.TERMLABEL_VALUE, new Term() ); + getBlanks().put( LexConstants.PRONUNCIATIONLABEL_VALUE, new Pronunciation() ); + getBlanks().put( LexConstants.ETYMOLOGYLABEL_VALUE, new Etymology() ); + getBlanks().put( LexConstants.FUNCTIONLABEL_VALUE, new Function() ); + getBlanks().put( LexConstants.SPELLINGLABEL_VALUE, new Spelling() ); + getBlanks().put( LexConstants.ENCYCLOPEDIA_ARTICLE_LABEL_VALUE, new EncyclopediaArticle() ); + getBlanks().put( LexConstants.DEFINITIONLABEL_VALUE, new Definition() ); + getBlanks().put( LexConstants.PASSAGELABEL_VALUE, new Passage() ); + getBlanks().put( LexConstants.SUBDEFINITIONLABEL_VALUE, new Subdefinition() ); + getBlanks().put( LexConstants.TRANSLATIONLABEL_VALUE, new TranslationEquivalent() ); + getBlanks().put( LexConstants.KEYWORDLABEL_VALUE, new Keyword() ); + getBlanks().put( LexConstants.RELATEDTERMLABEL_VALUE, new RelatedTerm() ); + getBlanks().put( LexConstants.MODELSENTENCELABEL_VALUE, new ModelSentence() ); + getBlanks().put( LexConstants.REGISTERLABEL_VALUE, new Register() ); + getBlanks().put( "analyticalNote", new AnalyticalNote() ); + getBlanks().put( "transitionalData", new TransitionalData() ); + // getBlanks().put( LexConstants.INPUTSESSIONLABEL_VALUE, new Preferences() ); + } + // catch (LexComponentException labe) + catch ( Exception labe ) + { + throw new ServletException( "LABE says: " + labe.getMessage() ); + } + } + + + /** + * Description of the Method + * + *@param request Description of Parameter + *@param response Description of Parameter + *@param chain Description of Parameter + *@exception IOException Description of Exception + *@exception ServletException Description of Exception + *@since + */ + public void doFilter( ServletRequest request, ServletResponse response, FilterChain chain ) throws IOException, ServletException + { + if ( request instanceof HttpServletRequest && response instanceof HttpServletResponse ) + { + HttpServletRequest req = (HttpServletRequest) request; + if ( null != req.getParameter( LexConstants.LABEL_REQ_PARAM ) ) + { + String labelValue = req.getParameter( LexConstants.LABEL_REQ_PARAM ); + try + { + // this if block is for TESTING ONLY + if ( getBlanks().get( labelValue ) != null ) + { + Class glass = getBlanks().get( labelValue ).getClass(); + LexComponent component = (LexComponent) glass.newInstance(); + //component.appendDebugMap( "LCFilterMadeNewInstance", component ); + req.setAttribute( LexConstants.COMPONENT_REQ_ATTR, component ); + } + else + { + req.setAttribute( "LCFilter says: ", "componentLabel was not in blank components" ); + } + } + catch ( InstantiationException ie ) + { + throw new ServletException( ie.getMessage() ); + } + catch ( IllegalAccessException iae ) + { + throw new ServletException( iae.getMessage() ); + } + } + else + { + req.setAttribute( "LexComponentFilter says: '", LexConstants.LABEL_REQ_PARAM + "' was not specified." ); + } + chain.doFilter( request, response ); + + try + { + LexComponentRepository.cleanup(); + } + catch ( LexRepositoryException lre ) + { + throw new ServletException( lre ); + } + } + else + { + throw new ServletException( "Filter only applicable to HTTP and HTTPS requests" ); + } + } + + + /** + * Description of the Method + * + *@since + */ + public void destroy() { } + + +//helper methods + +//constructors + /** + * Constructor for the LexComponentFilter object + * + *@since + */ + public LexComponentFilter() { } +} + diff --git a/src/java/org/thdl/lex/LexComponentRepository.java b/src/java/org/thdl/lex/LexComponentRepository.java new file mode 100644 index 0000000..159658e --- /dev/null +++ b/src/java/org/thdl/lex/LexComponentRepository.java @@ -0,0 +1,206 @@ +package org.thdl.lex; +import java.sql.*; +import java.util.*; + +import net.sf.hibernate.*; + +import org.thdl.lex.component.*; + + +/** + * Description of the Class + * + * @author travis + * @created October 1, 2003 + */ +public class LexComponentRepository +{ + private static long start; + + + /** + * Sets the start attribute of the LexComponentRepository object + * + * @param startTime The new start value + * @since + */ + private static void setStart( long startTime ) + { + start = startTime; + } + + + /** + * Gets the start attribute of the LexComponentRepository object + * + * @return The start value + * @since + */ + private static long getStart() + { + return start; + } + + + /** + * Gets the session attribute of the LexComponentRepository class + * + * @return The session value + * @exception HibernateException Description of Exception + * @since + */ + private static Session getSession() throws HibernateException + { + Session session = HibernateSession.currentSession(); + if ( !session.isConnected() ) + { +//session.reconnect(); + } + return session; + } + + + /** + * Description of the Method + * + * @return Description of the Returned Value + * @since + */ + private static long now() + { + return System.currentTimeMillis(); + } + + + /** + * Description of the Method + * + * @param comp Description of Parameter + * @return Description of the Returned Value + * @exception LexRepositoryException Description of Exception + * @since + */ + private static ITerm assertTerm( ILexComponent comp ) throws LexRepositoryException + { + ITerm term = null; + try + { + term = (ITerm) comp; + } + catch ( Exception e ) + { + throw new LexRepositoryException( "Query Component was not a term." ); + } + return term; + } + + + /** + * Queries the database for Terms that start with the string in the term + * property of the queryComponent. Sets entry property the first hit returned. + * + * @param lexQuery Description of Parameter + * @exception LexRepositoryException Description of Exception + * @since + */ + public static void findTermsByTerm( LexQuery lexQuery ) throws LexRepositoryException + { + setStart( now() ); + ITerm term = assertTerm( lexQuery.getQueryComponent() ); + if ( null == term.getTerm() ) + { + throw new LexRepositoryException( "Query Component term was null." ); + } + + Query query = null; + Iterator it = null; + String queryString = " FROM org.thdl.lex.component.Term as term WHERE term.term like '" + term.getTerm() + "%' AND term.deleted=0 ORDER BY term.term"; + try + { + query = getSession().createQuery( queryString ); + } + catch ( HibernateException he ) + { + throw new LexRepositoryException( he ); + } + + /* + try + { + query.setProperties( lexQuery.getQueryComponent() ); + } + catch ( HibernateException he ) + { + throw new LexRepositoryException( he ); + } + */ + try + { + it = query.iterate(); + } + catch ( HibernateException he ) + { + throw new LexRepositoryException( he ); + } + + if ( it.hasNext() ) + { + term = (ITerm) it.next(); + lexQuery.setEntry( term ); + lexQuery.getResults().clear(); + lexQuery.getResults().put( term.getMetaId(), term.getTerm() ); + } + while ( it.hasNext() ) + { + term = (ITerm) it.next(); + lexQuery.getResults().put( term.getMetaId(), term.getTerm() ); + } + lexQuery.setDuration( now() - getStart() ); + } + + + /** + * Description of the Method + * + * @param lexQuery Description of Parameter + * @exception LexRepositoryException Description of Exception + * @since + */ + public static void loadTermByPk( LexQuery lexQuery ) throws LexRepositoryException + { + ITerm term = assertTerm( lexQuery.getQueryComponent() ); + try + { + getSession().load( term, term.getMetaId() ); + lexQuery.setEntry( term ); + if ( !lexQuery.getResults().containsKey( term.getMetaId() ) ) + { + lexQuery.getResults().put( term.getMetaId(), term.getTerm() ); + } + } + catch ( HibernateException he ) + { + throw new LexRepositoryException( he ); + } + } + + + /** + * Description of the Method + * + * @exception LexRepositoryException Description of Exception + * @since + */ + public static void cleanup() throws LexRepositoryException + { + try + { + HibernateSession.closeSession(); + } + catch ( HibernateException he ) + { + throw new LexRepositoryException( he ); + } + } +} + diff --git a/src/java/org/thdl/lex/LexConstants.java b/src/java/org/thdl/lex/LexConstants.java new file mode 100644 index 0000000..412828f --- /dev/null +++ b/src/java/org/thdl/lex/LexConstants.java @@ -0,0 +1,89 @@ +package org.thdl.lex; + + +/** + * Description of the Class + * + *@author travis + *@created October 1, 2003 + */ +public class LexConstants +{ + /* + * REQUEST PARAM/ATTR NAMES AND VALUES USED BY LexComponentFilter.java + */ + //form field req params + public final static String LABEL_REQ_PARAM = "comp"; + public final static String TERMLABEL_VALUE = "term"; + public final static String PRONUNCIATIONLABEL_VALUE = "pronunciation"; + public final static String SPELLINGLABEL_VALUE = "spelling"; + public final static String ETYMOLOGYLABEL_VALUE = "etymology"; + public final static String FUNCTIONLABEL_VALUE = "function"; + public final static String ENCYCLOPEDIA_ARTICLE_LABEL_VALUE = "encyclopediaArticle"; + public final static String DEFINITIONLABEL_VALUE = "definition"; + public final static String SUBDEFINITIONLABEL_VALUE = "subdefinition"; + public final static String MODELSENTENCELABEL_VALUE = "modelSentence"; + public final static String PASSAGELABEL_VALUE = "passage"; + public final static String TRANSLATIONLABEL_VALUE = "translationEquivalent"; + public final static String RELATEDTERMLABEL_VALUE = "relatedTerm"; + public final static String REGISTERLABEL_VALUE = "register"; + public final static String KEYWORDLABEL_VALUE = "keyword"; + public final static String PREFERENCESLABEL_VALUE = "preferences"; + public final static String ANALYTICALNOTELABEL_VALUE = "analyticalNote"; + /* + * REQUEST PARAM NAMES AND VALUES USED BY LexActionServlet.java + */ + public final static String COMMAND_REQ_PARAM = "cmd"; + /* + * REQUEST PARAM NAMES AND VALUES USED BY LoginServlet.java + */ + public final static String USERNAME_REQ_PARAM = "username"; + public final static String PASSWORD_REQ_PARAM = "password"; + + /* + * -------------------------- + * REQUEST PARAM NAMES USED BY LexComponent.scrapeRequest(req) METHODS + * -------------------------- + */ + //Meta Data Request Params + public final static String NOTE_REQ_PARAM = "note"; + public final static String LANGUAGE_REQ_PARAM = "language"; + public final static String TRANSLATIONOF_REQ_PARAM = "translationOf"; + public final static String DIALECT_REQ_PARAM = "dialect"; + public final static String SOURCE_REQ_PARAM = "source"; + public final static String PROJSUB_REQ_PARAM = "projectSubject"; + public final static String SCRIPT_REQ_PARAM = "script"; + //Term Data Request Params + public final static String TERM_REQ_PARAM = "term"; + public final static String TERMID_REQ_PARAM = "termId"; + // public static final String SPELLINGNOTE_REQ_PARAM = "spellingNote"; + public final static String PRECEDENCE_REQ_PARAM = "precedence"; + //Definition Data Request Params + public final static String SUBDEFINITION_REQ_PARAM = "subdefinition"; + +//outgoing request attributes to jsp + public final static String COMPONENT_REQ_ATTR = "component"; + public final static String ORIGINALBEAN_REQ_ATTR = "original"; + public final static String MESSAGE_REQ_ATTR = "message"; + +//session attributes used by filters, servlet, commands and jsp + public final static String USER_SESS_ATTR = "user"; + public final static String PREFERENCES_SESS_ATTR = "preferences"; + public final static String LOGINTARGET_SESS_PARAM = "loginTarget"; + + public final static String DISPLAYMODE_SESS_ATTR = "displayMode"; + public final static String QUERY_SESS_ATTR = "query"; + public final static String TERMENTRYBEAN_SESS_ATTR = "termEntry"; + +//used by Servlet + public final static String JSP_DIR = "/jsp/"; + public final static String WELCOME_PAGE = "action?cmd=menu"; + public final static String ERROR_PAGE = "error.jsp"; +//used by Repository + public final static String DRIVER = "com.mysql.jdbc.Driver"; + + public final static String HIBERNATE_SESSION_KEY = "hib"; + + //public final static String URL = "jdbc:mysql://localhost/LexTorque"; +} + diff --git a/src/java/org/thdl/lex/LexConstantsSecure.java b/src/java/org/thdl/lex/LexConstantsSecure.java new file mode 100644 index 0000000..10c59e6 --- /dev/null +++ b/src/java/org/thdl/lex/LexConstantsSecure.java @@ -0,0 +1,18 @@ +package org.thdl.lex; + + +/** + * Description of the Class + * + * @author travis + * @created October 1, 2003 + */ +public class LexConstantsSecure +{ + final static String USER = ""; + final static String PASSWORD = ""; + final static String URL = "jdbc:mysql://localhost/Lex"; + +//public final static String URL = "jdbc:mysql://localhost/LexTorque"; +} + diff --git a/src/java/org/thdl/lex/LexFlatDataRepository.java b/src/java/org/thdl/lex/LexFlatDataRepository.java new file mode 100644 index 0000000..e5d369c --- /dev/null +++ b/src/java/org/thdl/lex/LexFlatDataRepository.java @@ -0,0 +1,300 @@ +package org.thdl.lex; + +import java.util.HashMap; +import java.sql.ResultSet; +import java.sql.ResultSetMetaData; +import java.sql.SQLException; + +public class LexFlatDataRepository +{ +//attributes + int displayLanguage=1; //this should default to the id for english from Languages table + private static LexFlatDataRepository instance; + + HashMap users; + HashMap userRoles; + HashMap projectSubjects; + HashMap sources; + HashMap languages; + HashMap scripts; + HashMap literarySources; + HashMap transitionalDataLabels; + + HashMap dialects; //represents merge table + HashMap majorDialectFamilies; + HashMap specificDialects; + + HashMap functionsGeneral; + HashMap functionsSpecific; + + HashMap spellingTypes; + HashMap phoneticsTypes; + HashMap relatedTermTypes; + HashMap etymologyTypes; + HashMap registers; + HashMap commentTypes; + +//accessors + public static LexFlatDataRepository getInstance() + { + if (null == instance) + instance = new LexFlatDataRepository(); + return instance; + } + public void setTransitionalDataLabels() + { + String sql = "SELECT id, transitionalDataLabel FROM TransitionalDataLabels"; + setTransitionalDataLabels( createMap( sql ) ); + } + public void setTransitionalDataLabels(HashMap transitionalDataLabels) { + this.transitionalDataLabels = transitionalDataLabels; + } + public HashMap getTransitionalDataLabels() { + return transitionalDataLabels; + } + public void setLiterarySources(HashMap literarySources) { + this.literarySources = literarySources; + } + public void setLiterarySources() + { + String sql="SELECT id, sourceNormalizedTitle FROM LiterarySources"; + setLiterarySources( createMap( sql ) ); + } + public HashMap getLiterarySources() { + return literarySources; + } + public void setUsers(HashMap users) { + this.users = users; + } + public void setUsers() { + String sql="SELECT id, firstName, lastName FROM Users"; + setUsers( createMap(sql) ); + } + public void setProjectSubjects(HashMap projectSubjects) { + this.projectSubjects = projectSubjects; + } + public void setProjectSubjects() { + String sql="SELECT id, projectSubject FROM projectSubjects"; + setProjectSubjects( createMap(sql) ); + } + public void setSources(HashMap sources) { + this.sources = sources; + } + public void setSources() { + String sql ="SELECT id, sourceTitle FROM Sources"; + setSources( createMap(sql) ); + } + public void setLanguages(HashMap languages) { + this.languages = languages; + } + public void setLanguages() { + String sql="SELECT id,Language FROM Languages"; + setLanguages( createMap(sql) ); + } + public void setScripts(HashMap scripts) { + this.scripts = scripts; + } + public void setScripts() { + String sql="SELECT id,script FROM scripts"; + setScripts( createMap(sql) ); + } + public HashMap getUsers() { + return users; + } + public HashMap getProjectSubjects() { + return projectSubjects; + } + public HashMap getSources() { + return sources; + } + public HashMap getLanguages() { + return languages; + } + public HashMap getScripts() { + return scripts; + } + public void setEtymologyTypes(HashMap etymologyTypes) { + this.etymologyTypes = etymologyTypes; + } + public void setEtymologyTypes() { + String sql="SELECT id, etymologyType FROM EtymologyTypes"; + setEtymologyTypes( createMap( sql ) ); + } + public HashMap getEtymologyTypes() { + return etymologyTypes; + } + public void setSpellingTypes() { + String sql="SELECT id, spellingType FROM SpellingTypes"; + setSpellingTypes( createMap( sql ) ); + } + public void setSpellingTypes(HashMap spellingTypes) { + this.spellingTypes = spellingTypes; + } + public HashMap getSpellingTypes() { + return spellingTypes; + } + public void setPhoneticsTypes() { + String sql="SELECT id, phoneticsType FROM PhoneticsTypes"; + setPhoneticsTypes( createMap( sql ) ); + } + public void setPhoneticsTypes(HashMap phoneticsTypes) { + this.phoneticsTypes = phoneticsTypes; + } + public HashMap getPhoneticsTypes() { + return phoneticsTypes; + } + public void setRelatedTermTypes() { + String sql="SELECT id, relatedTermType FROM RelatedTermTypes"; + setRelatedTermTypes( createMap( sql ) ); + } + public void setRelatedTermTypes(HashMap relatedTermTypes) { + this.relatedTermTypes = relatedTermTypes; + } + public HashMap getRelatedTermTypes() { + return relatedTermTypes; + } + public void setRegisters() { + String sql="SELECT id, register FROM Registers"; + setRegisters( createMap( sql ) ); + } + public void setRegisters(HashMap registers) { + this.registers = registers; + } + public HashMap getRegisters() { + return registers; + } + public void setFunctionsGeneral() { + String sql="SELECT id, functionGeneral FROM FunctionsGeneral"; + setFunctionsGeneral( createMap( sql ) ); + } + public void setFunctionsGeneral(HashMap functionsGeneral) { + this.functionsGeneral = functionsGeneral; + } + public HashMap getFunctionsGeneral() { + return functionsGeneral; + } + public void setMajorDialectFamilies() + { + String sql = "SELECT id, majorDialectFamily FROM MajorDialectFamilies"; + setMajorDialectFamilies( createMap( sql ) ); + } + public void setMajorDialectFamilies(HashMap majorDialectFamilies) { + this.majorDialectFamilies = majorDialectFamilies; + } + public HashMap getMajorDialectFamilies() { + return majorDialectFamilies; + } +// accessor methods for HashMap items + public String getUser(int userId) + { + return (String) getUsers().get( new Integer( userId ) ); + } + public String getProjectSubject(int projSubId) + { + return (String) getProjectSubjects().get( new Integer( projSubId ) ); + } + public String getSource(int sourceId) + { + return (String) getSources().get( new Integer( sourceId ) ); + } + public String getLanguage(int langId) + { + return (String) getLanguages().get( new Integer( langId ) ); + } + public String getScript(int scriptId) + { + return (String) getScripts().get( new Integer( scriptId ) ); + } + public String getLiterarySource(int litSourceId) + { + return (String) getLiterarySources().get( new Integer( litSourceId ) ); + } + public String getEtymologyType(int etymType) + { + return (String) getEtymologyTypes().get( new Integer( etymType ) ); + } + public String getSpellingType(int varType) + { + return (String) getSpellingTypes().get( new Integer( varType ) ); + } + public String getRegister( int reg ) + { + return (String) getRegisters().get( new Integer( reg ) ); + } + public String getFunctionGeneral( int funcGen ) + { + return (String) getFunctionsGeneral().get( new Integer( funcGen ) ); + } + public String getMajorDialectFamily( int dial ) + { + return (String)getMajorDialectFamilies().get( new Integer( dial ) ); + } + public String getTransitionalDataLabel( int label ) + { + return (String)getTransitionalDataLabels().get( new Integer( label ) ); + } +//helpers + public HashMap createMap(String sql) + { + ResultSet rs = null; + HashMap map = new HashMap(); + try + { + LexRepository lr = LexRepository.getInstance(); + rs = lr.getQueryStatement().executeQuery( sql ); + if (null != rs) + { + int i = 0; + Integer key=null; + String value=""; + while ( rs.next() ) + { + i = rs.getInt(1); + key = new Integer( i ); + value = rs.getString(2); + ResultSetMetaData rsmd = rs.getMetaData(); + int columnCount = rsmd.getColumnCount(); + for (int x=3; x <= columnCount; x++) + value = value + " " + rs.getString(x); + map.put( key , value ); + } + } + } catch (LexRepositoryException lre) + { + lre.printStackTrace(); + } catch (SQLException sqle) + { + sqle.printStackTrace(); + } + return map; + } + +//constructors + public LexFlatDataRepository() + { + setUsers(); + setProjectSubjects(); + setSources(); + setLanguages(); + setScripts(); + setLiterarySources(); + setEtymologyTypes(); + setSpellingTypes(); + setPhoneticsTypes(); + setRelatedTermTypes(); + setRegisters(); + setFunctionsGeneral(); + setMajorDialectFamilies(); + setTransitionalDataLabels(); + } +//main + public static void main(String[] args) + { + LexFlatDataRepository lfdr = new LexFlatDataRepository(); + System.out.println( lfdr.getUser(1) ); + System.out.println( lfdr.getProjectSubject(6) ); + System.out.println( lfdr.getSource(1) ); + System.out.println( lfdr.getLanguage(1) ); + System.out.println( lfdr.getEtymologyType(1) ); + } +} diff --git a/src/java/org/thdl/lex/LexQuery.hbm.xml b/src/java/org/thdl/lex/LexQuery.hbm.xml new file mode 100644 index 0000000..e6ed70c --- /dev/null +++ b/src/java/org/thdl/lex/LexQuery.hbm.xml @@ -0,0 +1,16 @@ + + + + + + + + org.thdl.lex.components.BaseLexQuery + + + + + + diff --git a/src/java/org/thdl/lex/LexQuery.java b/src/java/org/thdl/lex/LexQuery.java new file mode 100644 index 0000000..a786e80 --- /dev/null +++ b/src/java/org/thdl/lex/LexQuery.java @@ -0,0 +1,193 @@ +package org.thdl.lex; + +import org.thdl.lex.component.*; + +import net.sf.hibernate.*; +import org.apache.commons.beanutils.BeanUtils; +import java.util.*; +import java.sql.*; + + +/** + * Description of the Class + * + *@author travis + *@created October 1, 2003 + */ +public class LexQuery +{ + private ILexComponent queryComponent; + private ITerm entry; + private Map results; + private Enumeration mode; + private long duration; + + + /** + * Sets the duration attribute of the LexQuery object + * + *@param duration The new duration value + *@since + */ + public void setDuration( long duration ) + { + this.duration = duration; + } + + + /** + * Sets the queryComponent attribute of the LexQuery object + * + *@param queryComponent The new queryComponent value + *@since + */ + public void setQueryComponent( ILexComponent queryComponent ) + { + this.queryComponent = queryComponent; + } + + + /** + * Sets the entry attribute of the LexQuery object + * + *@param entry The new entry value + *@since + */ + public void setEntry( ITerm entry ) + { + this.entry = entry; + } + + + /** + * Sets the mode attribute of the LexQuery object + * + *@param mode The new mode value + *@since + */ + public void setMode( Enumeration mode ) + { + this.mode = mode; + } + + + /** + * Sets the results attribute of the LexQuery object + * + *@param results The new results value + *@since + */ + public void setResults( Map results ) + { + this.results = results; + } + + + /** + * Gets the duration attribute of the LexQuery object + * + *@return The duration value + *@since + */ + public long getDuration() + { + return duration; + } + + + /** + * Gets the queryComponent attribute of the LexQuery object + * + *@return The queryComponent value + *@since + */ + public ILexComponent getQueryComponent() + { + return queryComponent; + } + + + /** + * Gets the entry attribute of the LexQuery object + * + *@return The entry value + *@since + */ + public ITerm getEntry() + { + return entry; + } + + + /** + * Gets the mode attribute of the LexQuery object + * + *@return The mode value + *@since + */ + public Enumeration getMode() + { + return mode; + } + + + /** + * Gets the results attribute of the LexQuery object + * + *@return The results value + *@since + */ + public Map getResults() + { + if ( null == results ) + { + setResults( new HashMap() ); + } + return results; + } + + +//helper methods + /** + * Description of the Method + * + *@param parameters Description of Parameter + *@exception LexRepositoryException Description of Exception + *@since + */ + public void populate( Map parameters ) throws LexRepositoryException + { + try + { + BeanUtils.populate( this, parameters ); + } + catch ( IllegalAccessException iae ) + { + throw new LexRepositoryException( iae ); + } + catch ( java.lang.reflect.InvocationTargetException ite ) + { + throw new LexRepositoryException( ite ); + } + } + + +//constructors + + /** + * Constructor for the LexQuery object + * + *@since + */ + public LexQuery() { } + +//inner classes + + /* + * class LexQueryMode extends Enumeration + * { + * } + */ +} + + diff --git a/src/java/org/thdl/lex/LexRepository.java b/src/java/org/thdl/lex/LexRepository.java new file mode 100644 index 0000000..db0d8f5 --- /dev/null +++ b/src/java/org/thdl/lex/LexRepository.java @@ -0,0 +1,323 @@ +package org.thdl.lex; + +import java.util.*; +import java.sql.*; + + +/** + * Description of the Class + * + *@author travis + *@created September 26, 2002 + */ +public class LexRepository +{ +//attributes + private static LexRepository instance; + + private Connection connection; + + private Statement queryStatement; + private Statement updateStatement; + + +//accessors + /** + * Sets the connection attribute of the LexRepository object + * + *@param connection The new connection value + *@since + */ + private void setConnection( Connection connection ) + { + this.connection = connection; + } + + + /** + * Sets the queryStatement attribute of the LexRepository object + * + *@param queryStatement The new queryStatement value + *@since + */ + public void setQueryStatement( Statement queryStatement ) + { + this.queryStatement = queryStatement; + } + + + /** + * Sets the updateStatement attribute of the LexRepository object + * + *@param updateStatement The new updateStatement value + *@since + */ + public void setUpdateStatement( Statement updateStatement ) + { + this.updateStatement = updateStatement; + } + + + /** + * Gets the instance attribute of the LexRepository class + * + *@return The instance value + *@exception LexRepositoryException Description of the Exception + *@since + */ + public static LexRepository getInstance() throws LexRepositoryException + { + if ( instance == null ) + { + instance = new LexRepository(); + } + return instance; + } + + + /** + * Gets the connection attribute of the LexRepository object + * + *@return The connection value + *@since + */ + private Connection getConnection() + { + return connection; + } + + + /** + * Gets the queryStatement attribute of the LexRepository object + * + *@return The queryStatement value + *@since + */ + public Statement getQueryStatement() + { + return queryStatement; + } + + + /** + * Gets the updateStatement attribute of the LexRepository object + * + *@return The updateStatement value + *@since + */ + public Statement getUpdateStatement() + { + return updateStatement; + } + + +//helper methods + /** + * doQuery() performs a SELECT query on the database. + * + *@param sql This is a SQL String passed in from + * outside. + *@return ResultSet representing query results + *@exception LexRepositoryException Description of the Exception + *@since + */ + public ResultSet doQuery( String sql ) throws LexRepositoryException + { + try + { + return getQueryStatement().executeQuery( sql ); + } + catch ( SQLException sqle ) + { + throw new LexRepositoryException( sqle.getMessage() ); + } + } + + + /** + * doUpdate() performs an INSERT/UPDATE/DROP action + * + *@param sql Description of the Parameter + *@return Description of the Return Value + *@exception LexRepositoryException Description of the Exception + *@since + */ + public int doUpdate( String sql ) throws LexRepositoryException + { + try + { + return getQueryStatement().executeUpdate( sql ); + } + catch ( SQLException sqle ) + { + throw new LexRepositoryException( sqle.getMessage() ); + } + } + + + /** + * doInsert() is a wrapper for doUpdate() that returns the auto_increment + * primary key value of the newly inserted row + * + *@param sql Description of the Parameter + *@return Description of the Return Value + *@exception LexRepositoryException Description of the Exception + *@since + */ + public int doInsert( String sql ) throws LexRepositoryException + { + if ( null == sql ) + { + throw new LexRepositoryException( "SQL String was null" ); + } + if ( sql.equals( "" ) ) + { + throw new LexRepositoryException( "SQL String was empty" ); + } + try + { + ResultSet rs; + int returnVal = 0; + int i; + i = doUpdate( sql ); + if ( i > 0 ) + { + rs = doQuery( "SELECT LAST_INSERT_ID()" ); + while ( rs.next() ) + { + returnVal = rs.getInt( 1 ); + } + return returnVal; + } + else + { + returnVal = i; + } + throw new LexRepositoryException( "Insert affected 0 rows. Sql String was '" + sql + "'" ); + } + catch ( SQLException sqle ) + { + throw new LexRepositoryException( sqle.getMessage() ); + } + } + + +//main + /** + * The main program for the LexRepository class. This method tests all other + * methods in this class + * + *@param args The command line arguments + *@since + */ + public static void main( String[] args ) + { + String table = "Testing"; + String msg = "Successful"; + if ( args.length == 1 ) + { + msg = args[0]; + } + //TEST doInsert() method. Insert a message multiple times using the Testing table + System.out.println( "TEST ONE\n--------\n" ); + try + { + LexRepository lr = LexRepository.getInstance(); + String sqlString = "INSERT INTO Testing Values (NULL, '" + msg + "')"; + int newPK = lr.doInsert( sqlString ); + if ( newPK > 0 ) + { + System.out.println( "The newly inserted row's primary key equals " + newPK ); + } + else + { + System.out.println( "The row was not inserted" ); + } + } + catch ( LexRepositoryException lre ) + { + System.out.println( lre.getMessage() ); + lre.printStackTrace(); + } + + //TEST doQuery() method. Accept a table parameter from the command line and output + //a tab-delimited representation of the table. + System.out.println( "\nTEST TWO\n--------\n" ); + try + { + LexRepository lr = LexRepository.getInstance(); + ResultSet rs = lr.doQuery( "SELECT * FROM " + table ); + ResultSetMetaData rsmd = rs.getMetaData(); + + int cc = rsmd.getColumnCount(); + StringBuffer sb = new StringBuffer(); + for ( int i = 1; i <= cc; i++ ) + { + if ( 1 != i ) + { + sb.append( "\t" ); + } + sb.append( rsmd.getColumnLabel( i ) ); + } + System.out.println( sb.toString() ); + sb.setLength( 0 ); + while ( rs.next() ) + { + for ( int i = 1; i <= cc; i++ ) + { + if ( 1 != i ) + { + sb.append( "\t" ); + } + sb.append( rs.getString( i ) ); + } + + System.out.println( sb.toString() ); + sb.setLength( 0 ); + } + } + catch ( LexRepositoryException lre ) + { + System.out.println( lre.getMessage() ); + lre.printStackTrace(); + } + catch ( SQLException sqle ) + { + System.out.println( sqle.getMessage() ); + sqle.printStackTrace(); + } + } + + +//constructors + /** + * Default Constructor for the LexRepository object + * + *@exception LexRepositoryException Description of the Exception + *@since + */ + private LexRepository() throws LexRepositoryException + { + try + { + Class.forName( LexConstants.DRIVER ); + Properties props = new Properties(); + props.setProperty( "user", LexConstantsSecure.USER ); + props.setProperty( "password", LexConstantsSecure.PASSWORD ); + props.setProperty( "useUnicode", "true" ); + props.setProperty( "characterEncoding", "UTF-8" ); + setConnection( DriverManager.getConnection( LexConstantsSecure.URL, props ) ); + setQueryStatement( getConnection().createStatement() ); + setUpdateStatement( getConnection().createStatement() ); + } + catch ( ClassNotFoundException cnfe ) + { + throw new LexRepositoryException( "No Driver Available for: " + LexConstants.DRIVER ); + } + catch ( SQLException se ) + { + throw new LexRepositoryException( se.getMessage() ); + } + } +} + diff --git a/src/java/org/thdl/lex/LexRepositoryException.java b/src/java/org/thdl/lex/LexRepositoryException.java new file mode 100644 index 0000000..1e0f9bf --- /dev/null +++ b/src/java/org/thdl/lex/LexRepositoryException.java @@ -0,0 +1,59 @@ +package org.thdl.lex; + + +/** + * Description of the Class + * + *@author travis + *@created October 1, 2003 + */ +public class LexRepositoryException extends Exception +{ + /** + * Constructor for the LexRepositoryException object + * + *@since + */ + public LexRepositoryException() + { + super(); + } + + + /** + * Constructor for the LexRepositoryException object + * + *@param msg Description of Parameter + *@since + */ + public LexRepositoryException( String msg ) + { + super( msg ); + } + + + /** + * Constructor for the LexRepositoryException object + * + *@param e Description of Parameter + *@since + */ + public LexRepositoryException( Exception e ) + { + super( e ); + } + + + /** + * Constructor for the LexRepositoryException object + * + *@param msg Description of Parameter + *@param e Description of Parameter + *@since + */ + public LexRepositoryException( String msg, Exception e ) + { + super( msg, e ); + } +} + diff --git a/src/java/org/thdl/lex/LexUser.java b/src/java/org/thdl/lex/LexUser.java new file mode 100644 index 0000000..32be1db --- /dev/null +++ b/src/java/org/thdl/lex/LexUser.java @@ -0,0 +1,23 @@ +package org.thdl.lex; + +public class LexUser extends org.thdl.users.ThdlUser +{ + public boolean isGuest() + { + boolean bool = false; + if ( hasRole( "guest" ) ) + { + bool = true; + } + return bool; + } + public boolean isDeveloper() + { + boolean bool = false; + if ( hasRole( "dev" ) ) + { + bool = true; + } + return bool; + } +} diff --git a/src/java/org/thdl/lex/LexUtilities.java b/src/java/org/thdl/lex/LexUtilities.java new file mode 100644 index 0000000..9e6de65 --- /dev/null +++ b/src/java/org/thdl/lex/LexUtilities.java @@ -0,0 +1,107 @@ +package org.thdl.lex; + +import java.util.StringTokenizer; +import java.util.HashMap; + +public class LexUtilities +{ +/* public static String formatTimestamp( Timestamp time ) + { + // SimpleDateFormat formatter = new SimpleDateFormat("yyyy.MM.dd 'at' hh:mm:ss a zzz"); + // Date coDate = new Date( getCreatedOn().getTime() ); + // String dateString = formatter.format( coDate ); + } */ + public static String escape( String fromString ) + { + HashMap map = new HashMap(); + map.put("'", "\\'"); + /* + map.put("%", "\\%"); + map.put("_", "\\_"); + map.put("\"", "\\\""); + */ + StringBuffer targetString = new StringBuffer(""); + if ( null != fromString ) + { + StringTokenizer tokens = new StringTokenizer( fromString, "'%_\"", true ); + while ( tokens.hasMoreTokens() ) + { + String temp = tokens.nextToken(); + if ( map.containsKey( temp ) ) + { + temp = (String)map.get( temp ); + } + targetString.append( temp ); + } + } + return targetString.toString(); + } + public static int getResultSetSize( java.sql.ResultSet rs ) throws java.sql.SQLException + { + rs.last(); + int i = rs.getRow(); + rs.beforeFirst(); + return i; + } + public static int[] convertToIntArray( String[] source ) + { + if (null == source) + { + return null; + } + int[] target = new int[ source.length ]; + for ( int i=0; i 0 ) + { + results.next(); + setId( results.getInt( 1 ) ); + setUserId( results.getInt( 2 ) ); + setPreferencesName( results.getString( 3 ) ); + setProjectSubject( results.getInt( 4 ) ); + setSource( results.getInt( 5 ) ); + setLanguage( results.getInt( 6 ) ); + setScript( results.getInt( 7 ) ); + setDialect( results.getInt( 8 ) ); + setNote( results.getString( 9 ) ); + Boolean bool = Boolean.valueOf( results.getString( 10 ) ); + setUseDefaultProjSub( bool.booleanValue() ); + bool = Boolean.valueOf( results.getString( 11 ) ); + setUseDefaultSource( bool.booleanValue() ); + bool = Boolean.valueOf( results.getString( 12 ) ); + setUseDefaultLanguage( bool.booleanValue() ); + bool = Boolean.valueOf( results.getString( 13 ) ); + setUseDefaultScript( bool.booleanValue() ); + bool = Boolean.valueOf( results.getString( 14 ) ); + setUseDefaultDialect( bool.booleanValue() ); + bool = Boolean.valueOf( results.getString( 15 ) ); + setUseDefaultNote( bool.booleanValue() ); + setProjectSubjectSet( LexUtilities.convertTokensToIntArray( results.getString( 16 ) ) ); + setSourceSet( LexUtilities.convertTokensToIntArray( results.getString( 17 ) ) ); + setLanguageSet( LexUtilities.convertTokensToIntArray( results.getString( 18 ) ) ); + setScriptSet( LexUtilities.convertTokensToIntArray( results.getString( 19 ) ) ); + setDialectSet( LexUtilities.convertTokensToIntArray(results.getString( 20 ) ) ); + } + else { + insertNew(); + } + } catch (SQLException sqle) + { throw new LexComponentException( sqle.getMessage() ); } + } + + public void insertNew() throws LexComponentException + { + try { + String sql = "INSERT INTO Preferences ( id, userId ) VALUES ( NULL, " +getUserId() +" )"; + int i = LexRepository.getInstance().doUpdate( sql ); + setId( i ); + } + catch ( LexRepositoryException lre ) { throw new LexComponentException( lre.getMessage() ); } + } + + public void save() throws LexComponentException + { + try { + String sql = "SELECT id FROM Preferences WHERE userId = " + getUserId(); + ResultSet results = LexRepository.getInstance().doQuery( sql ); + if ( LexUtilities.getResultSetSize( results ) < 1 ) + { + insertNew(); + } + StringBuffer sqlBuffer = new StringBuffer(); + sqlBuffer.append( "UPDATE Preferences SET userId = "); + sqlBuffer.append( getUserId() ); + sqlBuffer.append( ", preferencesName = '"); + sqlBuffer.append( getPreferencesName() ); + sqlBuffer.append( "', projectSubject = "); + sqlBuffer.append( getProjectSubject() ); + sqlBuffer.append( ", source = "); + sqlBuffer.append( getSource() ); + sqlBuffer.append( ", language = "); + sqlBuffer.append( getLanguage() ); + sqlBuffer.append( ", script = "); + sqlBuffer.append( getScript() ); + sqlBuffer.append( ", dialect = "); + sqlBuffer.append( getDialect() ); + sqlBuffer.append( ", note = '"); + sqlBuffer.append( getNote() ); + sqlBuffer.append( "', useDefaultProjSub = '"); + sqlBuffer.append( getUseDefaultProjSub() ); + sqlBuffer.append( "', useDefaultSource = '"); + sqlBuffer.append( getUseDefaultSource() ); + sqlBuffer.append( "', useDefaultLanguage = '"); + sqlBuffer.append( getUseDefaultLanguage() ); + sqlBuffer.append( "', useDefaultScript = '"); + sqlBuffer.append( getUseDefaultScript() ); + sqlBuffer.append( "', useDefaultDialect = '"); + sqlBuffer.append( getUseDefaultDialect() ); + sqlBuffer.append( "', useDefaultNote = '"); + sqlBuffer.append( getUseDefaultNote() ); + sqlBuffer.append( "', projectSubjectSet = '"); + sqlBuffer.append( LexUtilities.convertIntArrayToTokens( getProjectSubjectSet() ) ); + sqlBuffer.append( "', sourceSet = '"); + sqlBuffer.append( LexUtilities.convertIntArrayToTokens( getSourceSet() ) ); + sqlBuffer.append( "', languageSet = '"); + sqlBuffer.append( LexUtilities.convertIntArrayToTokens( getLanguageSet() ) ); + sqlBuffer.append( "', scriptSet = '"); + sqlBuffer.append( LexUtilities.convertIntArrayToTokens( getScriptSet() ) ); + sqlBuffer.append( "', dialectSet = '"); + sqlBuffer.append( LexUtilities.convertIntArrayToTokens( getDialectSet() ) ); + sqlBuffer.append( "' WHERE id = "); + sqlBuffer.append( getId() ); + + int i = LexRepository.getInstance().doUpdate( sqlBuffer.toString() ); + } + catch ( LexRepositoryException lre ) { throw new LexComponentException( lre.getMessage() ); } + catch ( SQLException sqle ) { throw new LexComponentException( sqle.getMessage() ); } + } + +//constructors + public Preferences() throws LexRepositoryException, LexComponentException + { + setId( 0 ); + setUserId( 1 ); + setProjectSubject( 1 ); + setSource( 1 ); + setLanguage( 1 ); + setScript( 1 ); + setDialect( 1 ); + int[] temp = { getProjectSubject() }; + setProjectSubjectSet( temp ); + int[] temp2 = { getSource() }; + setSourceSet( temp2 ); + int[] temp3 = { getLanguage() }; + setLanguageSet( temp3 ); + int[] temp4 = { getDialect() }; + setDialectSet( temp4 ); + int[] temp5 = { getScript() }; + setScriptSet( temp5 ); + setNote( "Default Note" ); + } + public Preferences(ThdlUser user) throws LexRepositoryException, LexComponentException + { + this(); + setUserId( user.getId() ); + populate(); + /* setProjectSubject( user.getDefaultProjSub() ); + setSource( user.getDefaultSource() ); + setLanguage( user.getDefaultLanguage() ); + setScript( user.getDefaultScript() ); + setDialect( user.getDefaultDialect() ); */ + } + public static void main(String[] args) + { + try { + Preferences component = new Preferences(); + component.setUserId( 2 ); + component.save(); + System.out.println( component.getId() + " " + component.getUserId() ); + } + catch(Exception e){ e.printStackTrace(); } + } +} + diff --git a/src/java/org/thdl/lex/ThdlUtilities.java b/src/java/org/thdl/lex/ThdlUtilities.java new file mode 100644 index 0000000..7d4bca9 --- /dev/null +++ b/src/java/org/thdl/lex/ThdlUtilities.java @@ -0,0 +1,164 @@ +package org.thdl.lex; +import java.util.HashMap; + +import java.util.StringTokenizer; + + +/** + * Description of the Class + * + * @author travis + * @created October 5, 2003 + */ +public class ThdlUtilities +{ + /** + * Gets the resultSetSize attribute of the ThdlUtilities class + * + * @param rs Description of the Parameter + * @return The resultSetSize value + * @exception java.sql.SQLException Description of the Exception + */ + public static int getResultSetSize( java.sql.ResultSet rs ) throws java.sql.SQLException + { + rs.last(); + int i = rs.getRow(); + rs.beforeFirst(); + return i; + } + + + /* + public static String formatTimestamp( Timestamp time ) + { + / SimpleDateFormat formatter = new SimpleDateFormat("yyyy.MM.dd 'at' hh:mm:ss a zzz"); + / Date coDate = new Date( getCreatedOn().getTime() ); + / String dateString = formatter.format( coDate ); + } + */ + /** + * Description of the Method + * + * @param fromString Description of the Parameter + * @return Description of the Return Value + */ + public static String escape( String fromString ) + { + HashMap map = new HashMap(); + map.put( "'", "\\'" ); + /* + map.put("%", "\\%"); + map.put("_", "\\_"); + map.put("\"", "\\\""); + */ + StringBuffer targetString = new StringBuffer( "" ); + if ( null != fromString ) + { + StringTokenizer tokens = new StringTokenizer( fromString, "'%_\"", true ); + while ( tokens.hasMoreTokens() ) + { + String temp = tokens.nextToken(); + if ( map.containsKey( temp ) ) + { + temp = (String) map.get( temp ); + } + targetString.append( temp ); + } + } + return targetString.toString(); + } + + + /** + * Description of the Method + * + * @param source Description of the Parameter + * @return Description of the Return Value + */ + public static int[] convertToIntArray( String[] source ) + { + if ( null == source ) + { + return null; + } + int[] target = new int[source.length]; + for ( int i = 0; i < target.length; i++ ) + { + target[i] = Integer.parseInt( source[i] ); + } + return target; + } + + + /** + * Description of the Method + * + * @param source Description of the Parameter + * @return Description of the Return Value + */ + public static int[] convertTokensToIntArray( String source ) + { + if ( null == source ) + { + return null; + } + StringTokenizer sourceTokens = new StringTokenizer( source, ":" ); + int[] target = new int[sourceTokens.countTokens()]; + for ( int i = 0; sourceTokens.hasMoreTokens(); i++ ) + { + target[i] = Integer.parseInt( sourceTokens.nextToken() ); + } + return target; + } + + + /** + * Description of the Method + * + * @param source Description of the Parameter + * @return Description of the Return Value + */ + public static String convertIntArrayToTokens( int[] source ) + { + if ( null == source ) + { + return null; + } + StringBuffer target = new StringBuffer( "" ); + for ( int i = 0; i < source.length; i++ ) + { + target.append( Integer.toString( source[i] ) ); + if ( i < ( source.length - 1 ) ) + { + target.append( ":" ); + } + } + return target.toString(); + } + + + /** + * The main program for the ThdlUtilities class + * + * @param args The command line arguments + */ + public static void main( String[] args ) + { + String s = "It's stupid to use a % or a _ in a SQL Statement"; + System.out.println( ThdlUtilities.escape( s ) ); + + int[] ia = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + System.out.println( ThdlUtilities.convertIntArrayToTokens( ia ) ); + + String str = "9:8:7:6:5"; + int[] ia2 = ThdlUtilities.convertTokensToIntArray( str ); + String newStr = ""; + for ( int i = 0; i < 5; i++ ) + { + newStr = newStr + ia2[i] + " "; + } + System.out.println( newStr ); + + } +} + diff --git a/src/java/org/thdl/lex/UserSessionManager.java b/src/java/org/thdl/lex/UserSessionManager.java new file mode 100644 index 0000000..d25fceb --- /dev/null +++ b/src/java/org/thdl/lex/UserSessionManager.java @@ -0,0 +1,238 @@ +package org.thdl.lex; + +import org.thdl.users.*; +import org.thdl.lex.component.*; + +import javax.servlet.http.*; +import java.io.IOException; + + +/** + * Description of the Class + * + *@author travis + *@created October 1, 2003 + */ +public class UserSessionManager +{ +//attributes + + private static UserSessionManager INSTANCE = new UserSessionManager(); + + + /** + * Sets the preferences attribute of the UserSessionManager object + * + *@param session The new preferences value + *@param preferences The new preferences value + *@since + */ + public void setPreferences( HttpSession session, Preferences preferences ) + { + session.setAttribute( LexConstants.PREFERENCES_SESS_ATTR, preferences ); + } + + + /** + * Sets the query attribute of the UserSessionManager object + * + *@param session The new query value + *@param terms The new query value + *@since + */ + public void setQuery( HttpSession session, LexQuery terms ) + { + session.setAttribute( LexConstants.QUERY_SESS_ATTR, terms ); + } + + + /** + * Sets the sessionUser attribute of the UserSessionManager object + * + *@param session The new sessionUser value + *@param user The new sessionUser value + *@since + */ + public void setSessionUser( HttpSession session, ThdlUser user ) + { + session.setAttribute( LexConstants.USER_SESS_ATTR, user ); + String roleParam = "administrator"; + if ( user.hasRole( roleParam ) ) + { + //roles from Lex.Users.userRoleList (references Lex.UserRoles) + session.setMaxInactiveInterval( 60 * 60 * 8 ); + } + else + { + session.setMaxInactiveInterval( 60 * 45 ); + } + } + + + /** + * Sets the sessionLoginTarget attribute of the UserSessionManager object + * + *@param session The new sessionLoginTarget value + *@param loginTarget The new sessionLoginTarget value + *@since + */ + public void setSessionLoginTarget( HttpSession session, String loginTarget ) + { + session.setAttribute( LexConstants.LOGINTARGET_SESS_PARAM, loginTarget ); + } + + + /** + * Sets the displayMode attribute of the UserSessionManager object + * + *@param session The new displayMode value + *@param displayMode The new displayMode value + *@since + */ + public void setDisplayMode( HttpSession session, String displayMode ) + { + session.setAttribute( LexConstants.DISPLAYMODE_SESS_ATTR, displayMode ); + } + + + /** + * Sets the entry attribute of the UserSessionManager object + * + *@return The instance value + *@since + */ + /* + * public void setEntry( HttpSession session, ITerm entry ) + * { + * session.setAttribute( LexConstants.TERMENTRYBEAN_SESS_ATTR, entry ); + * } + */ + +//helper methods + /** + * Gets the instance attribute of the UserSessionManager class + * + *@return The instance value + *@since + */ + public static UserSessionManager getInstance() + { + return INSTANCE; + } + + + /** + * Gets the query attribute of the UserSessionManager object + * + *@param session Description of Parameter + *@return The query value + *@since + */ + public LexQuery getQuery( HttpSession session ) + { + Object query = session.getAttribute( LexConstants.QUERY_SESS_ATTR ); + if ( null == query || !( query instanceof LexQuery ) ) + { + query = new LexQuery(); + session.setAttribute( LexConstants.QUERY_SESS_ATTR, query ); + } + return (LexQuery) query; + } + + + /** + * Gets the preferences attribute of the UserSessionManager object + * + *@param session Description of Parameter + *@return The preferences value + *@since + */ + public Preferences getPreferences( HttpSession session ) + { + return (Preferences) session.getAttribute( LexConstants.PREFERENCES_SESS_ATTR ); + } + + + /** + * Gets the sessionUser attribute of the UserSessionManager object + * + *@param session Description of Parameter + *@return The sessionUser value + *@since + */ + public ThdlUser getSessionUser( HttpSession session ) + { + return (ThdlUser) session.getAttribute( LexConstants.USER_SESS_ATTR ); + } + + + /** + * Gets the sessionLoginTarget attribute of the UserSessionManager object + * + *@param session Description of Parameter + *@param clear Description of Parameter + *@return The sessionLoginTarget value + *@since + */ + public String getSessionLoginTarget( HttpSession session, boolean clear ) + { + String target = (String) session.getAttribute( LexConstants.LOGINTARGET_SESS_PARAM ); + if ( clear ) + { + session.removeAttribute( LexConstants.LOGINTARGET_SESS_PARAM ); + } + return target; + } + + + /** + * Gets the entry attribute of the UserSessionManager object + * + *@param session Description of Parameter + *@since + */ + /* + * public ITerm getEntry( HttpSession session ) + * { + * return (ITerm) session.getAttribute( LexConstants.TERMENTRYBEAN_SESS_ATTR ); + * } + */ + + /** + * Description of the Method + * + *@param session Description of Parameter + *@since + */ + public void removeSessionUser( HttpSession session ) + { + session.removeAttribute( LexConstants.USER_SESS_ATTR ); + session.removeAttribute( LexConstants.PREFERENCES_SESS_ATTR ); + } + + + /** + * Description of the Method + * + *@param request Description of Parameter + *@param response Description of Parameter + *@param url Description of Parameter + *@exception IOException Description of Exception + *@since + */ + public static void doRedirect( HttpServletRequest request, HttpServletResponse response, String url ) throws IOException + { + String redirect = response.encodeRedirectURL( request.getContextPath() + url ); + response.sendRedirect( redirect ); + } + + + //constructor + /** + * Constructor for the UserSessionManager object + * + *@since + */ + private UserSessionManager() { } +} + diff --git a/src/java/org/thdl/lex/commands/AbortCommand.java b/src/java/org/thdl/lex/commands/AbortCommand.java new file mode 100644 index 0000000..d2fb106 --- /dev/null +++ b/src/java/org/thdl/lex/commands/AbortCommand.java @@ -0,0 +1,47 @@ +package org.thdl.lex.commands; + +import javax.servlet.http.HttpServletRequest; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + + +/** + * Description of the Class + * + * @author travis + * @created October 1, 2003 + */ +public class AbortCommand implements Command +{ + private String next; + + + /** + * Description of the Method + * + * @param req Description of Parameter + * @param component Description of Parameter + * @return Description of the Returned Value + * @exception CommandException Description of Exception + * @since + */ + public String execute( HttpServletRequest req, ILexComponent component ) throws CommandException + { + req.setAttribute( "termtool.msg", "Operation Aborted" ); + return next; + } + + + /** + * Constructor for the AbortCommand object + * + * @param next Description of Parameter + * @since + */ + public AbortCommand( String next ) + { + this.next = next; + } +} + diff --git a/src/java/org/thdl/lex/commands/Command.java b/src/java/org/thdl/lex/commands/Command.java new file mode 100644 index 0000000..3436b86 --- /dev/null +++ b/src/java/org/thdl/lex/commands/Command.java @@ -0,0 +1,27 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + + +/** + * Description of the Interface + * + *@author travis + *@created October 3, 2003 + */ +public interface Command +{ + /** + * Description of the Method + * + *@param req Description of Parameter + *@param component Description of Parameter + *@return Description of the Returned Value + *@exception CommandException Description of Exception + *@since + */ + public String execute( javax.servlet.http.HttpServletRequest req, ILexComponent component ) throws CommandException; + // public java.util.HashMap initForwards(); +} + diff --git a/src/java/org/thdl/lex/commands/CommandException.java b/src/java/org/thdl/lex/commands/CommandException.java new file mode 100644 index 0000000..6610df2 --- /dev/null +++ b/src/java/org/thdl/lex/commands/CommandException.java @@ -0,0 +1,62 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + + +/** + * Description of the Class + * + *@author travis + *@created October 1, 2003 + */ +public class CommandException extends Exception +{ + /** + * Constructor for the CommandException object + * + *@since + */ + public CommandException() + { + super(); + } + + + /** + * Constructor for the CommandException object + * + *@param msg Description of Parameter + *@since + */ + public CommandException( String msg ) + { + super( msg ); + } + + + /** + * Constructor for the CommandException object + * + *@param msg Description of Parameter + *@param e Description of Parameter + *@since + */ + public CommandException( String msg, Exception e ) + { + super( msg, e ); + } + + + /** + * Constructor for the CommandException object + * + *@param e Description of Parameter + *@since + */ + public CommandException( Exception e ) + { + super( e ); + } +} + diff --git a/src/java/org/thdl/lex/commands/CommandToken.java b/src/java/org/thdl/lex/commands/CommandToken.java new file mode 100644 index 0000000..0a5506c --- /dev/null +++ b/src/java/org/thdl/lex/commands/CommandToken.java @@ -0,0 +1,49 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import java.security.MessageDigest; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpSession; + +public class CommandToken +{ + public static void set(HttpServletRequest req) + { + HttpSession session = req.getSession(true); + long systime = System.currentTimeMillis(); + byte[] time = new Long(systime).toString().getBytes(); + byte[] id = session.getId().getBytes(); + try + { + MessageDigest md5 = MessageDigest.getInstance("MD5"); + md5.update(id); + md5.update(time); + String token = toHex( md5.digest() ); + req.setAttribute("token", token); + session.setAttribute("token", token); + } + catch (Exception e) + { + System.err.println("Unable to calculate MD5 Digests.\nCould not create unique token"); + } + } + public static boolean isValid(HttpServletRequest req) + { + HttpSession session = req.getSession(true); + String requestToken = req.getParameter("token"); + String sessionToken = (String) session.getAttribute("token"); + if (requestToken == null && sessionToken == null) + return false; + else + return requestToken.equals(sessionToken);//this is a boolean + } + public static String toHex(byte[] digest) + { + StringBuffer buf = new StringBuffer(); + for (int i = 0; i < digest.length; i++) + buf.append( Integer.toHexString( (int)digest[i] & 0x00ff ) );//param=BITWISE operation + return buf.toString(); + } +} diff --git a/src/java/org/thdl/lex/commands/DisplayCommand.java b/src/java/org/thdl/lex/commands/DisplayCommand.java new file mode 100644 index 0000000..3f61e3c --- /dev/null +++ b/src/java/org/thdl/lex/commands/DisplayCommand.java @@ -0,0 +1,113 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpSession; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; + + +/** + * Description of the Class + * + *@author travis + *@created October 3, 2003 + */ +public class DisplayCommand extends LexCommand implements Command +{ +//helper methods + /** + * Sets the displayMode attribute of the DisplayCommand object + * + *@param req The new displayMode value + *@since + */ + public void setDisplayMode( HttpServletRequest req ) + { + String cmd = req.getParameter( LexConstants.COMMAND_REQ_PARAM ); + if ( cmd.equals( "display" ) ) + { + req.getSession( true ).setAttribute( LexConstants.DISPLAYMODE_SESS_ATTR, "brief" ); + } + else if ( cmd.equals( "displayFull" ) ) + { + req.getSession( true ).setAttribute( LexConstants.DISPLAYMODE_SESS_ATTR, "full" ); + } + else if ( cmd.equals( "editEntry" ) ) + { + req.getSession( true ).setAttribute( LexConstants.DISPLAYMODE_SESS_ATTR, "edit" ); + } + } + + +//contract methods + + /** + * Description of the Method + * + *@param req Description of Parameter + *@param component Description of Parameter + *@return Description of the Returned Value + *@exception CommandException Description of Exception + *@since + */ + public String execute( HttpServletRequest req, ILexComponent component ) throws CommandException + { + try + { + component.populate( req.getParameterMap() ); + + LexQuery query = getSessionMgr().getQuery( req.getSession( true ) ); + query.setQueryComponent( component ); + LexComponentRepository.loadTermByPk( query ); + + String msg = null; + String forward = (String) getForwards().get( req.getParameter( LexConstants.LABEL_REQ_PARAM ) ); + setNext( forward ); + + req.setAttribute( LexConstants.MESSAGE_REQ_ATTR, msg ); + + return getNext(); + } + catch ( LexComponentException e ) + { + throw new CommandException( e ); + } + catch ( LexRepositoryException e ) + { + throw new CommandException( e ); + } + } + + + /** + * Description of the Method + * + *@return Description of the Returned Value + *@since + */ + public HashMap initForwards() + { + HashMap map = new HashMap(); + map.put( LexConstants.TERMLABEL_VALUE, "displayEntry.jsp" ); + map.put( LexConstants.ENCYCLOPEDIA_ARTICLE_LABEL_VALUE, "displayEntry.jsp" ); + return map; + } + + +//constructors + /** + * Constructor for the DisplayCommand object + * + *@since + */ + public DisplayCommand() + { + super(); + setForwards( initForwards() ); + } +} + diff --git a/src/java/org/thdl/lex/commands/FindCommand.java b/src/java/org/thdl/lex/commands/FindCommand.java new file mode 100644 index 0000000..7b57164 --- /dev/null +++ b/src/java/org/thdl/lex/commands/FindCommand.java @@ -0,0 +1,104 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpSession; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.*; + + +/** + * Description of the Class + * + *@author travis + *@created October 1, 2003 + */ +public class FindCommand extends LexCommand implements Command +{ +//helper methods + /** + * Description of the Method + * + *@param req Description of Parameter + *@param component Description of Parameter + *@return Description of the Returned Value + *@exception CommandException Description of Exception + *@since + */ + public String execute( HttpServletRequest req, ILexComponent component ) throws CommandException + { + try + { + String msg = null; + String forward = (String) getForwards().get( req.getParameter( LexConstants.LABEL_REQ_PARAM ) ); + + component.populate( req.getParameterMap() ); + setNext( forward ); + + if ( component instanceof ITerm ) + { + ITerm term = (ITerm) component; + + LexQuery query = getSessionMgr().getQuery( req.getSession( true ) ); + + query.setQueryComponent( term ); + LexComponentRepository.findTermsByTerm( query ); + Iterator iterator = query.getResults().keySet().iterator(); + if ( iterator.hasNext() ) + { + setNext( "displayEntry.jsp" ); + getSessionMgr().setQuery( req.getSession( true ), query ); + msg = "There are " + query.getResults().size() + " terms matching " + term.getTerm(); + } + else + { + setNext( "menu.jsp" ); + msg = "There were no terms matching " + term.getTerm(); + } + } + req.setAttribute( LexConstants.MESSAGE_REQ_ATTR, msg ); + return getNext(); + } + catch ( LexComponentException e ) + { + throw new CommandException( e ); + } + catch ( LexRepositoryException e ) + { + throw new CommandException( e ); + } + } + + + /** + * Description of the Method + * + *@return Description of the Returned Value + *@since + */ + public HashMap initForwards() + { + HashMap map = new HashMap(); + map.put( LexConstants.TERMLABEL_VALUE, "displayEntry.jsp" ); + // map.put( LexConstants.DEFINITIONLABEL_VALUE, "displayEntry.jsp" ); + // map.put( LexConstants.PASSAGELABEL_VALUE, "displayEntry.jsp" ); + return map; + } + + +//constructors + /** + * Constructor for the FindCommand object + * + *@since + */ + public FindCommand() + { + super(); + setForwards( initForwards() ); + } +} + diff --git a/src/java/org/thdl/lex/commands/GetInsertFormCommand.java b/src/java/org/thdl/lex/commands/GetInsertFormCommand.java new file mode 100644 index 0000000..84ae1b3 --- /dev/null +++ b/src/java/org/thdl/lex/commands/GetInsertFormCommand.java @@ -0,0 +1,65 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpSession; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; + +public class GetInsertFormCommand extends LexCommand implements Command +{ +//contract methods + public String execute(HttpServletRequest req, ILexComponent component) throws CommandException + { + /* try + { + setComponent( (LexComponent)component ); + getComponent().scrapeRequest( req ); + String msg="You have reached the New Entry form."; + req.setAttribute(LexConstants.MESSAGE_REQ_ATTR, msg); + if ( req.getParameter( LexConstants.COMMAND_REQ_PARAM ).equals( "annotate" ) ) + { + setComponent( (LexComponent)component ); + getComponent().scrapeRequest( req ); + getComponent().query(); + + AnalyticalNote note = new AnalyticalNote(); + note.setParentMeta( getComponent().getMetaId() ); + req.setAttribute( LexConstants.COMPONENT_REQ_ATTR, component ); + } + getSessionMgr().setDisplayMode( req.getSession( true ), "addNewComponent" ); + */ return getNext(); +/* } + catch (LexComponentException e) + { + throw new CommandException("Lex Action Exception: " + e.getMessage()); + } + */ } +//helper methods + public HashMap initForwards() + { + HashMap map = new HashMap(); + map.put( LexConstants.TERMLABEL_VALUE, "displayEntry.jsp?formMode=insert" ); + map.put( LexConstants.SUBDEFINITIONLABEL_VALUE, "displayEntry.jsp?formMode=insert" ); + map.put( LexConstants.TRANSLATIONLABEL_VALUE, "displayEntry.jsp?formMode=insert" ); + // map.put( LexConstants.DEFINITIONLABEL_VALUE, "displayEntry.jsp" ); + // map.put( LexConstants.PASSAGELABEL_VALUE, "displayEntry.jsp" ); + return map; + } + +//constructors + public GetInsertFormCommand() + { + super(); + setForwards( initForwards() ); + } + public GetInsertFormCommand( String next ) + { + super(); + setNext( next ); + } +} + diff --git a/src/java/org/thdl/lex/commands/GetTranslationFormCommand.java b/src/java/org/thdl/lex/commands/GetTranslationFormCommand.java new file mode 100644 index 0000000..2592fae --- /dev/null +++ b/src/java/org/thdl/lex/commands/GetTranslationFormCommand.java @@ -0,0 +1,57 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import org.thdl.users.*; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpSession; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; + +public class GetTranslationFormCommand extends LexCommand implements Command +{ +//helper methods + public String execute(HttpServletRequest req, ILexComponent component) throws CommandException + { + /* try + { + ThdlUser user = getSessionMgr().getSessionUser( req.getSession( true ) ); + Preferences preferences = getSessionMgr().getPreferences( req.getSession( true ) ); + Meta meta = new Meta( user, preferences ); + meta.scrapeRequest( req ); + component.setTranslationOf( Integer.parseInt( req.getParameter("id") ) ); + meta.insert(); + setComponent( component ); + getComponent().query( Integer.parseInt( req.getParameter("id") ) ); + req.setAttribute( LexConstants.ORIGINALBEAN_REQ_ATTR , getComponent() ); + getComponent().setMeta( meta ); + //getComponent().insert(); + String msg="You have reached the Translation Form"; + req.setAttribute(LexConstants.MESSAGE_REQ_ATTR, msg); + getSessionMgr().setDisplayMode( req.getSession( true ) , "addEditForm" ); + */ return getNext(); +/* } + catch (LexComponentException e) + { + throw new CommandException("Lex Action Exception: " + e.getMessage()); + } + */ } + public HashMap initForwards() + { + return null; + } +//constructors + public GetTranslationFormCommand() + { + super(); + } + public GetTranslationFormCommand( String next ) + { + super(); + setNext( next ); + } +} + diff --git a/src/java/org/thdl/lex/commands/GetUpdateFormCommand.java b/src/java/org/thdl/lex/commands/GetUpdateFormCommand.java new file mode 100644 index 0000000..a593428 --- /dev/null +++ b/src/java/org/thdl/lex/commands/GetUpdateFormCommand.java @@ -0,0 +1,84 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpSession; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; + +public class GetUpdateFormCommand extends LexCommand implements Command +{ +//helper methods + public String execute(HttpServletRequest req, ILexComponent component) throws CommandException + { + /* try + { + String msg = null; + setComponent( (LexComponent)component ); + getComponent().scrapeRequest( req ); + getComponent().query(); + if ( getComponent().getTranslationOf() > 0 ) + { + try + { + LexComponent lab = (LexComponent) getComponent().getClass().newInstance(); + lab.query( getComponent().getTranslationOf() ); + req.setAttribute( LexConstants.ORIGINALBEAN_REQ_ATTR , lab ); + } + catch (InstantiationException ie) + { + throw new LexComponentException("InstantiationException Says: " +ie.getMessage()); + } + catch (IllegalAccessException iae) + { + throw new LexComponentException("IllegalAccessException Says: " +iae.getMessage()); + } + } + Meta meta = getComponent().getMeta(); + if ( getSessionMgr().getSessionUser( req.getSession( true ) ).getId() == meta.getCreatedBy() ) + { + msg="You have reached the Update Form"; + getSessionMgr().setDisplayMode( req.getSession( true ) , "addEditForm" ); + setNext( "displayForm.jsp?formMode=update" ); + } + else + { + msg="A dictionary component can only be edited by the person who created it"; + setNext( "displayEntry.jsp" ); + } + req.setAttribute(LexConstants.MESSAGE_REQ_ATTR, msg); + */ return getNext(); +/* } + catch (LexComponentException e) + { + throw new CommandException("Lex Action Exception: " + e.getMessage()); + } + */ + } + public HashMap initForwards() + { + HashMap map = new HashMap(); + //map.put( LexConstants.TERMLABEL_VALUE, "displayEntry.jsp?formMode=update" ); + //map.put( LexConstants.SUBDEFINITIONLABEL_VALUE, "displayEntry.jsp?formMode=update" ); + //map.put( LexConstants.TRANSLATIONLABEL_VALUE, "displayEntry.jsp?formMode=update" ); + // map.put( LexConstants.DEFINITIONLABEL_VALUE, "displayEntry.jsp" ); + // map.put( LexConstants.PASSAGELABEL_VALUE, "displayEntry.jsp" ); + return map; + } + +//constructors + public GetUpdateFormCommand() + { + super(); + //setForwards( initForwards() ); + } + public GetUpdateFormCommand( String next ) + { + super(); + setNext( next ); + } +} + diff --git a/src/java/org/thdl/lex/commands/InsertCommand.java b/src/java/org/thdl/lex/commands/InsertCommand.java new file mode 100644 index 0000000..a787a93 --- /dev/null +++ b/src/java/org/thdl/lex/commands/InsertCommand.java @@ -0,0 +1,97 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import org.thdl.users.*; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpSession; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; + +public class InsertCommand extends LexCommand implements Command +{ +//helper methods + public String execute(HttpServletRequest req, ILexComponent component) throws CommandException + { + /* try + { + if ( CommandToken.isValid( req ) ) + { + ThdlUser user = getSessionMgr().getSessionUser( req.getSession( true ) ); + Preferences preferences = getSessionMgr().getPreferences( req.getSession( true ) ); + if ( null == user ) + throw new CommandException("No ThdlUser available in this Session"); + if ( null == preferences ) + throw new CommandException("No Preferences available in this Session"); + Meta meta = new Meta( user, preferences ); + meta.scrapeRequest( req ); + meta.insert(); + + setComponent( component ); + getComponent().setMeta( meta ); + getComponent().scrapeRequest( req ); + getComponent().insert(); + getComponent().query(); + req.setAttribute( "jumpToLocation", getComponent().getLabel() ); + if ( null != req.getParameter( "analyticalNote" ) ) + { + if ( ! LexConstants.LABEL_REQ_PARAM.equals( LexConstants.ANALYTICALNOTELABEL_VALUE ) + && ! "".equals( req.getParameter( "analyticalNote" ) ) ) + { + AnalyticalNote note = new AnalyticalNote(); + Meta mb = new Meta( meta ); + mb.insert(); + note.setMeta( mb ); + note.scrapeRequest( req ); + note.setParentMeta( getComponent().getMetaId() ); + note.insert(); + } + } + + String msg="Successful new " +getComponent().getLabel() +" Entry."; + req.setAttribute(LexConstants.MESSAGE_REQ_ATTR, msg); + if ( getComponent() instanceof Term ) + getSessionMgr().setEntry( req.getSession( true ) , new TermEntry( getComponent() ) ); + else + getSessionMgr().getEntry( req.getSession( true ) ).rebuild(); + if (null == getSessionMgr().getResults( req.getSession( true ) ) ) + { + LexComponent[] results = {component}; + getSessionMgr().setResults( req.getSession( true ), results ); + } + getSessionMgr().setDisplayMode( req.getSession( true ), "edit" ); + } + else + { + String msg="Invalid Reload Attempted"; + req.setAttribute(LexConstants.MESSAGE_REQ_ATTR, msg); + } + */ return getNext(); +/* } + catch (LexComponentException e) + { + throw new CommandException("Lex Action Exception: " + e.getMessage()); + } + catch (LexEntryException e) + { + throw new CommandException("Lex Entry Exception: " + e.getMessage()); + } + */ } + public HashMap initForwards() + { + HashMap map = new HashMap(); + // map.put( LexConstants.TERMLABEL_VALUE, "displayEntry.jsp" ); + // map.put( LexConstants.DEFINITIONLABEL_VALUE, "displayEntry.jsp" ); + // map.put( LexConstants.PASSAGELABEL_VALUE, "displayEntry.jsp" ); + return map; + } + public InsertCommand( String next) + { + super( next ); + setForwards( initForwards() ); + } +} + diff --git a/src/java/org/thdl/lex/commands/LexCommand.java b/src/java/org/thdl/lex/commands/LexCommand.java new file mode 100644 index 0000000..af3b37f --- /dev/null +++ b/src/java/org/thdl/lex/commands/LexCommand.java @@ -0,0 +1,204 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; +//import org.apache.commons.beanutils.*; + +import javax.servlet.http.HttpServletRequest; +import java.util.LinkedList; +import java.util.HashMap; +import java.util.Map; + + +/** + * Description of the Class + * + *@author travis + *@created October 3, 2003 + */ +public abstract class LexCommand implements Command +{ +//attributes + private String defaultNext; + private String next; + private ILexComponent component; + private LinkedList resultsList; + private HashMap forwards; + private UserSessionManager sessionMgr; + + +//accessors + /** + * Sets the sessionMgr attribute of the LexCommand object + * + *@param sessionMgr The new sessionMgr value + *@since + */ + public void setSessionMgr( UserSessionManager sessionMgr ) + { + this.sessionMgr = sessionMgr; + } + + + /** + * Sets the defaultNext attribute of the LexCommand object + * + *@param defaultNext The new defaultNext value + *@since + */ + public void setDefaultNext( String defaultNext ) + { + this.defaultNext = defaultNext; + } + + + /** + * Sets the forwards attribute of the LexCommand object + * + *@param forwards The new forwards value + *@since + */ + public void setForwards( HashMap forwards ) + { + this.forwards = forwards; + } + + + /** + * Sets the resultsList attribute of the LexCommand object + * + *@param resultsList The new resultsList value + *@since + */ + public void setResultsList( LinkedList resultsList ) + { + this.resultsList = resultsList; + } + + + /** + * Sets the next attribute of the LexCommand object + * + *@param next The new next value + *@since + */ + public void setNext( String next ) + { + this.next = next; + } + + + /** + * Sets the component attribute of the LexCommand object + * + *@return The sessionMgr value + *@since + */ + /* + * public void setComponent( ILexComponent component ) + * { + * this.component = component; + * } + */ + + /** + * Gets the sessionMgr attribute of the LexCommand object + * + *@return The sessionMgr value + *@since + */ + public UserSessionManager getSessionMgr() + { + if ( null == sessionMgr ) + { + setSessionMgr( UserSessionManager.getInstance() ); + } + return sessionMgr; + } + + + /** + * Gets the defaultNext attribute of the LexCommand object + * + *@return The defaultNext value + *@since + */ + public String getDefaultNext() + { + return defaultNext; + } + + + /** + * Gets the forwards attribute of the LexCommand object + * + *@return The forwards value + *@since + */ + public HashMap getForwards() + { + return forwards; + } + + + /** + * Gets the resultsList attribute of the LexCommand object + * + *@return The resultsList value + *@since + */ + public LinkedList getResultsList() + { + return resultsList; + } + + + /** + * Gets the next attribute of the LexCommand object + * + *@return The next value + *@since + */ + public String getNext() + { + return next; + } + + + /** + * Gets the component attribute of the LexCommand object + * + *@param next Description of Parameter + *@since + */ + /* + * public ILexComponent getComponent() + * { + * return component; + * } + */ +//helpers + +//constructors + + /** + * Constructor for the LexCommand object + * + *@param next Description of Parameter + *@since + */ + public LexCommand( String next ) + { + setDefaultNext( next ); + setNext( getDefaultNext() ); + } + + + /** + * Constructor for the LexCommand object + * + *@since + */ + public LexCommand() { } +} + diff --git a/src/java/org/thdl/lex/commands/NewComponentCommand.java b/src/java/org/thdl/lex/commands/NewComponentCommand.java new file mode 100644 index 0000000..f65bb50 --- /dev/null +++ b/src/java/org/thdl/lex/commands/NewComponentCommand.java @@ -0,0 +1,76 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpSession; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; + +public class NewComponentCommand extends LexCommand implements Command +{ +//helper methods + public String execute(HttpServletRequest req, ILexComponent component) throws CommandException + { +/* try + { + + setComponent( (LexComponent)component ); + getComponent().scrapeRequest( req ); + String msg="You have reached the form for creating a New " +getComponent().getLabel() +" Entry."; + String forward = (String)getForwards().get( req.getParameter( LexConstants.LABEL_REQ_PARAM ) ); + setNext( forward ); + + if ( getComponent() instanceof Term ) + { + Term term = (Term)getComponent(); + LexComponent[] results = term.find(); + req.setAttribute( "term", term.getTerm() ); + if ( results.length > 0) + { + component=results[0]; + msg="There are already " + results.length + " entries for " + term.getTerm() +"."; + getSessionMgr().setEntry( req.getSession( true), new TermEntry( component ) ); + } + else + { + //REQUEST SHOULD BE FORWARDED TO /lex/action?cmd=getInsertForm HERE + results = new LexComponent[1]; + results[0] = component; + msg="Click the 'New Entry' button to add " + term.getTerm() +" to the dictionary."; + getSessionMgr().setEntry( req.getSession( true), null ); + } + setNext( "displayEntry.jsp?mode=newTerm"); + getSessionMgr().setResults( req.getSession( true ), results ); + } + req.setAttribute(LexConstants.MESSAGE_REQ_ATTR, msg); + */ return getNext(); + /* } + catch (LexComponentException e) + { + throw new CommandException("Lex Action Exception: " + e.getMessage()); + } + catch (LexEntryException e) + { + throw new CommandException("Lex Entry Exception: " + e.getMessage()); + } + */ } + public HashMap initForwards() + { + HashMap map = new HashMap(); + map.put( LexConstants.TERMLABEL_VALUE, "displayEntry.jsp" ); + map.put( LexConstants.DEFINITIONLABEL_VALUE, "displayEntry.jsp" ); + map.put( LexConstants.PASSAGELABEL_VALUE, "displayEntry.jsp" ); + return map; + } + +//constructors + public NewComponentCommand() + { + super(); + setForwards( initForwards() ); + } +} + diff --git a/src/java/org/thdl/lex/commands/NullCommand.java b/src/java/org/thdl/lex/commands/NullCommand.java new file mode 100644 index 0000000..59f5c2e --- /dev/null +++ b/src/java/org/thdl/lex/commands/NullCommand.java @@ -0,0 +1,24 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import javax.servlet.http.HttpServletRequest; + +public class NullCommand extends LexCommand implements Command +{ + public String execute(HttpServletRequest req, ILexComponent component) throws CommandException + { + if( null == req.getParameter( LexConstants.COMMAND_REQ_PARAM ) ) + req.setAttribute( LexConstants.MESSAGE_REQ_ATTR, "Start from here." ); + if( "login" == req.getParameter( LexConstants.COMMAND_REQ_PARAM ) + && null != getSessionMgr().getSessionUser( req.getSession(true) ) ) + setNext("menu.jsp"); + return getNext(); + } + public java.util.HashMap initForwards() { return null;} + public NullCommand(String next) + { + super(next); + } +} diff --git a/src/java/org/thdl/lex/commands/PreferencesCommand.java b/src/java/org/thdl/lex/commands/PreferencesCommand.java new file mode 100644 index 0000000..df00ee2 --- /dev/null +++ b/src/java/org/thdl/lex/commands/PreferencesCommand.java @@ -0,0 +1,69 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import javax.servlet.http.HttpServletRequest; + +public class PreferencesCommand extends LexCommand implements Command +{ + public String execute(HttpServletRequest req, ILexComponent component) throws CommandException + { + Preferences isb = UserSessionManager.getInstance().getPreferences( req.getSession( true ) ); + if (req.getParameter( LexConstants.COMMAND_REQ_PARAM ).equals("setMetaPrefs") ) + { + isb.setLanguageSet( LexUtilities.convertToIntArray( req.getParameterValues( "languages" ) ) ); + isb.setDialectSet( LexUtilities.convertToIntArray( req.getParameterValues( "dialects" ) ) ); + isb.setSourceSet( LexUtilities.convertToIntArray( req.getParameterValues( "sources" ) ) ); + isb.setProjectSubjectSet( LexUtilities.convertToIntArray( req.getParameterValues( "projectSubjects" ) ) ); + isb.setScriptSet( LexUtilities.convertToIntArray( req.getParameterValues( "scripts" ) ) ); + } + else if ( req.getParameter( LexConstants.COMMAND_REQ_PARAM ).equals("setMetaDefaults") ) + { + isb.setLanguage( Integer.parseInt( req.getParameter( "language" ) ) ); + isb.setDialect( Integer.parseInt( req.getParameter( "dialect" ) ) ); + isb.setSource( Integer.parseInt( req.getParameter( "source" ) ) ); + isb.setProjectSubject( Integer.parseInt( req.getParameter( "projectSubject" ) ) ); + isb.setScript( Integer.parseInt( req.getParameter( "script" ) ) ); + isb.setNote( req.getParameter( "note" ) ); + if ( null != req.getParameter( "useDefaultLanguage" ) && req.getParameter( "useDefaultLanguage" ).equals( "true" ) ) + isb.setUseDefaultLanguage( true ); + else + isb.setUseDefaultLanguage( false ); + if ( null != req.getParameter( "useDefaultDialect" ) && req.getParameter( "useDefaultDialect" ).equals( "true" ) ) + isb.setUseDefaultDialect( true ); + else + isb.setUseDefaultDialect( false ); + if ( null != req.getParameter( "useDefaultSource" ) && req.getParameter( "useDefaultSource" ).equals( "true" ) ) + isb.setUseDefaultSource( true ); + else + isb.setUseDefaultSource( false ); + if ( null != req.getParameter( "useDefaultProjSub" ) && req.getParameter( "useDefaultProjSub" ).equals( "true" ) ) + isb.setUseDefaultProjSub( true ); + else + isb.setUseDefaultProjSub( false ); + if ( null != req.getParameter( "useDefaultScript" ) && req.getParameter( "useDefaultScript" ).equals( "true" ) ) + isb.setUseDefaultScript( true ); + else + isb.setUseDefaultScript( false ); + if ( null != req.getParameter( "useDefaultNote" ) && req.getParameter( "useDefaultNote" ).equals( "true" ) ) + isb.setUseDefaultNote( true ); + else + isb.setUseDefaultNote( false ); + } + try + { + isb.save(); + } + catch( LexComponentException lre ) + { + throw new CommandException( "LexComponentException says: " + lre.getMessage() ); + } + return getNext(); + } + public java.util.HashMap initForwards() { return null;} + public PreferencesCommand(String next) + { + super(next); + } +} diff --git a/src/java/org/thdl/lex/commands/RemoveCommand.java b/src/java/org/thdl/lex/commands/RemoveCommand.java new file mode 100644 index 0000000..8ae96f5 --- /dev/null +++ b/src/java/org/thdl/lex/commands/RemoveCommand.java @@ -0,0 +1,56 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpSession; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; + +public class RemoveCommand extends LexCommand implements Command +{ +//helper methods + public String execute(HttpServletRequest req, ILexComponent component) throws CommandException + { + /* try + { + setComponent( (LexComponent)component ); + getComponent().query( Integer.parseInt( req.getParameter("id") ) ); + String msg=null; + String forward = (String)getForwards().get( req.getParameter( LexConstants.LABEL_REQ_PARAM ) ); + setNext( forward ); + int successCode = getComponent().remove(); + msg=null; + String label = req.getParameter( LexConstants.LABEL_REQ_PARAM ); + if (successCode > 0) + { msg = "The " + label +" was successfully removed."; } + else + { msg = "Failure: The " + getComponent().getLabel() +" was not removed."; } + + req.setAttribute(LexConstants.MESSAGE_REQ_ATTR, msg); + */ return getNext(); + /* } + catch (LexComponentException e) + { + throw new CommandException("Lex Action Exception: " + e.getMessage()); + } + */ } + public HashMap initForwards() + { + HashMap map = new HashMap(); + map.put( LexConstants.TERMLABEL_VALUE, "menu.jsp" ); + // map.put( LexConstants.DEFINITIONLABEL_VALUE, "displayEntry.jsp" ); + // map.put( LexConstants.PASSAGELABEL_VALUE, "displayEntry.jsp" ); + return map; + } + +//constructors + public RemoveCommand() + { + super(); + setForwards( initForwards() ); + } +} + diff --git a/src/java/org/thdl/lex/commands/TestingCommand.java b/src/java/org/thdl/lex/commands/TestingCommand.java new file mode 100644 index 0000000..d979a9b --- /dev/null +++ b/src/java/org/thdl/lex/commands/TestingCommand.java @@ -0,0 +1,30 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import javax.servlet.http.HttpServletRequest; + +public class TestingCommand extends LexCommand implements Command +{ + public String execute(HttpServletRequest req, ILexComponent component) throws CommandException + { + + try { + /* Term term = new Term(); + term.setId( 1 ); + term.setTerm( "this is a word" ); + term.setAnalyticalNotes( new java.util.Vector() ); + term.getAnalyticalNotes().add( "hi" ); + term.getAnalyticalNotes().add( "there" ); + req.setAttribute( "term", term ); */ + return getNext(); + } + catch (Exception e) { throw new CommandException( e.toString() + e.getMessage() ); } + } + public java.util.HashMap initForwards() { return null;} + public TestingCommand(String next) + { + super(next); + } +} diff --git a/src/java/org/thdl/lex/commands/UpdateCommand.java b/src/java/org/thdl/lex/commands/UpdateCommand.java new file mode 100644 index 0000000..59444cc --- /dev/null +++ b/src/java/org/thdl/lex/commands/UpdateCommand.java @@ -0,0 +1,76 @@ +package org.thdl.lex.commands; + +import org.thdl.lex.*; +import org.thdl.lex.component.*; + +import org.thdl.users.*; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpSession; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; + +public class UpdateCommand extends LexCommand implements Command +{ +//helper methods + public String execute(HttpServletRequest req, ILexComponent component) throws CommandException + { + /* try + { + if ( CommandToken.isValid( req ) ) + { + Preferences preferences=getSessionMgr().getPreferences( req.getSession(true) ); + ThdlUser user = getSessionMgr().getSessionUser( req.getSession(true) ); + String msg="Successful Update"; + + setComponent( component ); + getComponent().query( Integer.parseInt( req.getParameter("id") ) ); + getComponent().scrapeRequest( req ); + getComponent().update( user, preferences ); + + req.setAttribute(LexConstants.MESSAGE_REQ_ATTR, msg); + req.setAttribute( "jumpToLocation", getComponent().getLabel() ); + getSessionMgr().getEntry( req.getSession( true ) ).rebuild(); + getSessionMgr().setDisplayMode( req.getSession( true ), "edit" ); + } + else + { + String msg="Invalid Reload Attempted"; + req.setAttribute(LexConstants.MESSAGE_REQ_ATTR, msg); + } + */ return getNext(); +/* } + catch (LexComponentException e) + { + throw new CommandException("Lex Action Exception: " + e.getMessage()); + } + catch (LexEntryException e) + { + throw new CommandException("Lex Entry Exception: " + e.getMessage()); + } + */ } + public HashMap initForwards() + { + HashMap map = new HashMap(); + map.put( LexConstants.TERMLABEL_VALUE, "displayEntry.jsp" ); + map.put( LexConstants.SUBDEFINITIONLABEL_VALUE, "displayEntry.jsp" ); + map.put( LexConstants.TRANSLATIONLABEL_VALUE, "displayEntry.jsp" ); + // map.put( LexConstants.DEFINITIONLABEL_VALUE, "displayEntry.jsp" ); + // map.put( LexConstants.PASSAGELABEL_VALUE, "displayEntry.jsp" ); + return map; + } + +//constructors + public UpdateCommand() + { + super(); + //setForwards( initForwards() ); + } + public UpdateCommand( String next ) + { + this(); + setNext( next ); + } +} + diff --git a/src/java/org/thdl/lex/component/AnalyticalNote.java b/src/java/org/thdl/lex/component/AnalyticalNote.java new file mode 100644 index 0000000..fbe66b1 --- /dev/null +++ b/src/java/org/thdl/lex/component/AnalyticalNote.java @@ -0,0 +1,9 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + + +public class AnalyticalNote extends BaseAnalyticalNote implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/BaseAnalyticalNote.java b/src/java/org/thdl/lex/component/BaseAnalyticalNote.java new file mode 100644 index 0000000..eb8c797 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseAnalyticalNote.java @@ -0,0 +1,79 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseAnalyticalNote extends LexComponent implements Serializable,org.thdl.lex.component.IAnalyticalNote { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** nullable persistent field */ + private java.lang.String analyticalNote; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseAnalyticalNote(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.String analyticalNote, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.analyticalNote = analyticalNote; + this.parent = parent; + } + + /** default constructor */ + public BaseAnalyticalNote() { + } + + /** minimal constructor */ + public BaseAnalyticalNote(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta) { + super(deleted, analyticalNotes, translations, meta); + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.String getAnalyticalNote() { + return this.analyticalNote; + } + + public void setAnalyticalNote(java.lang.String analyticalNote) { + this.analyticalNote = analyticalNote; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseDefinition.java b/src/java/org/thdl/lex/component/BaseDefinition.java new file mode 100644 index 0000000..de3ed94 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseDefinition.java @@ -0,0 +1,184 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseDefinition extends LexComponent implements org.thdl.lex.component.IDefinition,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** persistent field */ + private java.lang.Short precedence; + + /** nullable persistent field */ + private java.lang.String definition; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** persistent field */ + private List subdefinitions; + + /** persistent field */ + private List glosses; + + /** persistent field */ + private List keywords; + + /** persistent field */ + private List modelSentences; + + /** persistent field */ + private List translationEquivalents; + + /** persistent field */ + private List relatedTerms; + + /** persistent field */ + private List passages; + + /** persistent field */ + private List registers; + + /** full constructor */ + public BaseDefinition(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.String definition, org.thdl.lex.component.ILexComponent parent, List subdefinitions, List glosses, List keywords, List modelSentences, List translationEquivalents, List relatedTerms, List passages, List registers) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.definition = definition; + this.parent = parent; + this.subdefinitions = subdefinitions; + this.glosses = glosses; + this.keywords = keywords; + this.modelSentences = modelSentences; + this.translationEquivalents = translationEquivalents; + this.relatedTerms = relatedTerms; + this.passages = passages; + this.registers = registers; + } + + /** default constructor */ + public BaseDefinition() { + } + + /** minimal constructor */ + public BaseDefinition(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Short precedence, List subdefinitions, List glosses, List keywords, List modelSentences, List translationEquivalents, List relatedTerms, List passages, List registers) { + super(deleted, analyticalNotes, translations, meta); + this.precedence = precedence; + this.subdefinitions = subdefinitions; + this.glosses = glosses; + this.keywords = keywords; + this.modelSentences = modelSentences; + this.translationEquivalents = translationEquivalents; + this.relatedTerms = relatedTerms; + this.passages = passages; + this.registers = registers; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.String getDefinition() { + return this.definition; + } + + public void setDefinition(java.lang.String definition) { + this.definition = definition; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public java.util.List getSubdefinitions() { + return this.subdefinitions; + } + + public void setSubdefinitions(java.util.List subdefinitions) { + this.subdefinitions = subdefinitions; + } + + public java.util.List getGlosses() { + return this.glosses; + } + + public void setGlosses(java.util.List glosses) { + this.glosses = glosses; + } + + public java.util.List getKeywords() { + return this.keywords; + } + + public void setKeywords(java.util.List keywords) { + this.keywords = keywords; + } + + public java.util.List getModelSentences() { + return this.modelSentences; + } + + public void setModelSentences(java.util.List modelSentences) { + this.modelSentences = modelSentences; + } + + public java.util.List getTranslationEquivalents() { + return this.translationEquivalents; + } + + public void setTranslationEquivalents(java.util.List translationEquivalents) { + this.translationEquivalents = translationEquivalents; + } + + public java.util.List getRelatedTerms() { + return this.relatedTerms; + } + + public void setRelatedTerms(java.util.List relatedTerms) { + this.relatedTerms = relatedTerms; + } + + public java.util.List getPassages() { + return this.passages; + } + + public void setPassages(java.util.List passages) { + this.passages = passages; + } + + public java.util.List getRegisters() { + return this.registers; + } + + public void setRegisters(java.util.List registers) { + this.registers = registers; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseEncyclopediaArticle.java b/src/java/org/thdl/lex/component/BaseEncyclopediaArticle.java new file mode 100644 index 0000000..190fcd0 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseEncyclopediaArticle.java @@ -0,0 +1,93 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseEncyclopediaArticle extends LexComponent implements org.thdl.lex.component.IEncyclopediaArticle,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** persistent field */ + private java.lang.String article; + + /** persistent field */ + private java.lang.String articleTitle; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseEncyclopediaArticle(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.String article, java.lang.String articleTitle, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.article = article; + this.articleTitle = articleTitle; + this.parent = parent; + } + + /** default constructor */ + public BaseEncyclopediaArticle() { + } + + /** minimal constructor */ + public BaseEncyclopediaArticle(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.String article, java.lang.String articleTitle) { + super(deleted, analyticalNotes, translations, meta); + this.article = article; + this.articleTitle = articleTitle; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.String getArticle() { + return this.article; + } + + public void setArticle(java.lang.String article) { + this.article = article; + } + + public java.lang.String getArticleTitle() { + return this.articleTitle; + } + + public void setArticleTitle(java.lang.String articleTitle) { + this.articleTitle = articleTitle; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseEtymology.java b/src/java/org/thdl/lex/component/BaseEtymology.java new file mode 100644 index 0000000..fbe0049 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseEtymology.java @@ -0,0 +1,118 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseEtymology extends LexComponent implements Serializable,org.thdl.lex.component.IEtymology { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** nullable persistent field */ + private java.lang.Short loanLanguage; + + /** persistent field */ + private java.lang.Short etymologyType; + + /** persistent field */ + private java.lang.String derivation; + + /** persistent field */ + private java.lang.String etymologyDescription; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseEtymology(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.Short loanLanguage, java.lang.Short etymologyType, java.lang.String derivation, java.lang.String etymologyDescription, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.loanLanguage = loanLanguage; + this.etymologyType = etymologyType; + this.derivation = derivation; + this.etymologyDescription = etymologyDescription; + this.parent = parent; + } + + /** default constructor */ + public BaseEtymology() { + } + + /** minimal constructor */ + public BaseEtymology(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Short etymologyType, java.lang.String derivation, java.lang.String etymologyDescription) { + super(deleted, analyticalNotes, translations, meta); + this.etymologyType = etymologyType; + this.derivation = derivation; + this.etymologyDescription = etymologyDescription; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.Short getLoanLanguage() { + return this.loanLanguage; + } + + public void setLoanLanguage(java.lang.Short loanLanguage) { + this.loanLanguage = loanLanguage; + } + + public java.lang.Short getEtymologyType() { + return this.etymologyType; + } + + public void setEtymologyType(java.lang.Short etymologyType) { + this.etymologyType = etymologyType; + } + + public java.lang.String getDerivation() { + return this.derivation; + } + + public void setDerivation(java.lang.String derivation) { + this.derivation = derivation; + } + + public java.lang.String getEtymologyDescription() { + return this.etymologyDescription; + } + + public void setEtymologyDescription(java.lang.String etymologyDescription) { + this.etymologyDescription = etymologyDescription; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseFunction.java b/src/java/org/thdl/lex/component/BaseFunction.java new file mode 100644 index 0000000..92f4300 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseFunction.java @@ -0,0 +1,80 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseFunction extends LexComponent implements org.thdl.lex.component.IFunction,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** persistent field */ + private java.lang.Short function; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseFunction(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.Short function, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.function = function; + this.parent = parent; + } + + /** default constructor */ + public BaseFunction() { + } + + /** minimal constructor */ + public BaseFunction(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Short function) { + super(deleted, analyticalNotes, translations, meta); + this.function = function; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.Short getFunction() { + return this.function; + } + + public void setFunction(java.lang.Short function) { + this.function = function; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseGloss.java b/src/java/org/thdl/lex/component/BaseGloss.java new file mode 100644 index 0000000..5593e36 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseGloss.java @@ -0,0 +1,91 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseGloss extends LexComponent implements org.thdl.lex.component.IGloss,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** nullable persistent field */ + private java.lang.String gloss; + + /** nullable persistent field */ + private java.lang.String translation; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseGloss(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.String gloss, java.lang.String translation, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.gloss = gloss; + this.translation = translation; + this.parent = parent; + } + + /** default constructor */ + public BaseGloss() { + } + + /** minimal constructor */ + public BaseGloss(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta) { + super(deleted, analyticalNotes, translations, meta); + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.String getGloss() { + return this.gloss; + } + + public void setGloss(java.lang.String gloss) { + this.gloss = gloss; + } + + public java.lang.String getTranslation() { + return this.translation; + } + + public void setTranslation(java.lang.String translation) { + this.translation = translation; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseGrammaticalFunction.java b/src/java/org/thdl/lex/component/BaseGrammaticalFunction.java new file mode 100644 index 0000000..c72acf8 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseGrammaticalFunction.java @@ -0,0 +1,80 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseGrammaticalFunction extends LexComponent implements org.thdl.lex.component.IFunction,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** persistent field */ + private java.lang.Short function; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseGrammaticalFunction(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.Short function, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.function = function; + this.parent = parent; + } + + /** default constructor */ + public BaseGrammaticalFunction() { + } + + /** minimal constructor */ + public BaseGrammaticalFunction(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Short function) { + super(deleted, analyticalNotes, translations, meta); + this.function = function; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.Short getFunction() { + return this.function; + } + + public void setFunction(java.lang.Short function) { + this.function = function; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseKeyword.java b/src/java/org/thdl/lex/component/BaseKeyword.java new file mode 100644 index 0000000..7fd0d90 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseKeyword.java @@ -0,0 +1,79 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseKeyword extends LexComponent implements org.thdl.lex.component.IKeyword,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** nullable persistent field */ + private java.lang.String keyword; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseKeyword(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.String keyword, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.keyword = keyword; + this.parent = parent; + } + + /** default constructor */ + public BaseKeyword() { + } + + /** minimal constructor */ + public BaseKeyword(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta) { + super(deleted, analyticalNotes, translations, meta); + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.String getKeyword() { + return this.keyword; + } + + public void setKeyword(java.lang.String keyword) { + this.keyword = keyword; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseLexComponent.java b/src/java/org/thdl/lex/component/BaseLexComponent.java new file mode 100644 index 0000000..32c42f5 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseLexComponent.java @@ -0,0 +1,120 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseLexComponent implements org.thdl.lex.component.ILexComponent,Serializable { + + /** identifier field */ + private java.lang.Integer metaId; + + /** nullable persistent field */ + private java.lang.Integer translationOf; + + /** persistent field */ + private java.lang.Boolean deleted; + + /** persistent field */ + private List analyticalNotes; + + /** persistent field */ + private Set translations; + + /** persistent field */ + private org.thdl.lex.component.Meta meta; + + /** full constructor */ + public BaseLexComponent(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta) { + this.translationOf = translationOf; + this.deleted = deleted; + this.analyticalNotes = analyticalNotes; + this.translations = translations; + this.meta = meta; + } + + /** default constructor */ + public BaseLexComponent() { + } + + /** minimal constructor */ + public BaseLexComponent(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta) { + this.deleted = deleted; + this.analyticalNotes = analyticalNotes; + this.translations = translations; + this.meta = meta; + } + + public java.lang.Integer getMetaId() { + return this.metaId; + } + + public void setMetaId(java.lang.Integer metaId) { + this.metaId = metaId; + } + + public java.lang.Integer getTranslationOf() { + return this.translationOf; + } + + public void setTranslationOf(java.lang.Integer translationOf) { + this.translationOf = translationOf; + } + + public java.lang.Boolean getDeleted() { + return this.deleted; + } + + public void setDeleted(java.lang.Boolean deleted) { + this.deleted = deleted; + } + + public java.util.List getAnalyticalNotes() { + return this.analyticalNotes; + } + + public void setAnalyticalNotes(java.util.List analyticalNotes) { + this.analyticalNotes = analyticalNotes; + } + + public java.util.Set getTranslations() { + return this.translations; + } + + public void setTranslations(java.util.Set translations) { + this.translations = translations; + } + + public org.thdl.lex.component.Meta getMeta() { + return this.meta; + } + + public void setMeta(org.thdl.lex.component.Meta meta) { + this.meta = meta; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof BaseLexComponent) ) return false; + BaseLexComponent castOther = (BaseLexComponent) other; + return new EqualsBuilder() + .append(this.getMetaId(), castOther.getMetaId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getMetaId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseModelSentence.java b/src/java/org/thdl/lex/component/BaseModelSentence.java new file mode 100644 index 0000000..3f2f5dd --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseModelSentence.java @@ -0,0 +1,92 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseModelSentence extends LexComponent implements org.thdl.lex.component.IModelSentence,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** persistent field */ + private java.lang.Integer subdefinitionId; + + /** nullable persistent field */ + private java.lang.String modelSentence; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseModelSentence(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.Integer subdefinitionId, java.lang.String modelSentence, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.subdefinitionId = subdefinitionId; + this.modelSentence = modelSentence; + this.parent = parent; + } + + /** default constructor */ + public BaseModelSentence() { + } + + /** minimal constructor */ + public BaseModelSentence(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer subdefinitionId) { + super(deleted, analyticalNotes, translations, meta); + this.subdefinitionId = subdefinitionId; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.Integer getSubdefinitionId() { + return this.subdefinitionId; + } + + public void setSubdefinitionId(java.lang.Integer subdefinitionId) { + this.subdefinitionId = subdefinitionId; + } + + public java.lang.String getModelSentence() { + return this.modelSentence; + } + + public void setModelSentence(java.lang.String modelSentence) { + this.modelSentence = modelSentence; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BasePassage.java b/src/java/org/thdl/lex/component/BasePassage.java new file mode 100644 index 0000000..18557a3 --- /dev/null +++ b/src/java/org/thdl/lex/component/BasePassage.java @@ -0,0 +1,115 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BasePassage extends LexComponent implements org.thdl.lex.component.IPassage,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** nullable persistent field */ + private java.lang.String literarySource; + + /** nullable persistent field */ + private java.lang.String spelling; + + /** nullable persistent field */ + private java.lang.String pagination; + + /** nullable persistent field */ + private java.lang.String passage; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BasePassage(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.String literarySource, java.lang.String spelling, java.lang.String pagination, java.lang.String passage, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.literarySource = literarySource; + this.spelling = spelling; + this.pagination = pagination; + this.passage = passage; + this.parent = parent; + } + + /** default constructor */ + public BasePassage() { + } + + /** minimal constructor */ + public BasePassage(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta) { + super(deleted, analyticalNotes, translations, meta); + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.String getLiterarySource() { + return this.literarySource; + } + + public void setLiterarySource(java.lang.String literarySource) { + this.literarySource = literarySource; + } + + public java.lang.String getSpelling() { + return this.spelling; + } + + public void setSpelling(java.lang.String spelling) { + this.spelling = spelling; + } + + public java.lang.String getPagination() { + return this.pagination; + } + + public void setPagination(java.lang.String pagination) { + this.pagination = pagination; + } + + public java.lang.String getPassage() { + return this.passage; + } + + public void setPassage(java.lang.String passage) { + this.passage = passage; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BasePronunciation.java b/src/java/org/thdl/lex/component/BasePronunciation.java new file mode 100644 index 0000000..315d06e --- /dev/null +++ b/src/java/org/thdl/lex/component/BasePronunciation.java @@ -0,0 +1,93 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BasePronunciation extends LexComponent implements org.thdl.lex.component.IPronunciation,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** persistent field */ + private java.lang.String phonetics; + + /** persistent field */ + private java.lang.Short phoneticsType; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BasePronunciation(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.String phonetics, java.lang.Short phoneticsType, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.phonetics = phonetics; + this.phoneticsType = phoneticsType; + this.parent = parent; + } + + /** default constructor */ + public BasePronunciation() { + } + + /** minimal constructor */ + public BasePronunciation(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.String phonetics, java.lang.Short phoneticsType) { + super(deleted, analyticalNotes, translations, meta); + this.phonetics = phonetics; + this.phoneticsType = phoneticsType; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.String getPhonetics() { + return this.phonetics; + } + + public void setPhonetics(java.lang.String phonetics) { + this.phonetics = phonetics; + } + + public java.lang.Short getPhoneticsType() { + return this.phoneticsType; + } + + public void setPhoneticsType(java.lang.Short phoneticsType) { + this.phoneticsType = phoneticsType; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseRegister.java b/src/java/org/thdl/lex/component/BaseRegister.java new file mode 100644 index 0000000..975b397 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseRegister.java @@ -0,0 +1,80 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseRegister extends LexComponent implements org.thdl.lex.component.IRegister,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** persistent field */ + private java.lang.Short register; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseRegister(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.Short register, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.register = register; + this.parent = parent; + } + + /** default constructor */ + public BaseRegister() { + } + + /** minimal constructor */ + public BaseRegister(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Short register) { + super(deleted, analyticalNotes, translations, meta); + this.register = register; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.Short getRegister() { + return this.register; + } + + public void setRegister(java.lang.Short register) { + this.register = register; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseRelatedTerm.java b/src/java/org/thdl/lex/component/BaseRelatedTerm.java new file mode 100644 index 0000000..b21ecad --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseRelatedTerm.java @@ -0,0 +1,92 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseRelatedTerm extends LexComponent implements Serializable,org.thdl.lex.component.IRelatedTerm { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** nullable persistent field */ + private java.lang.String relatedTerm; + + /** persistent field */ + private java.lang.Short relatedTermType; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseRelatedTerm(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.String relatedTerm, java.lang.Short relatedTermType, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.relatedTerm = relatedTerm; + this.relatedTermType = relatedTermType; + this.parent = parent; + } + + /** default constructor */ + public BaseRelatedTerm() { + } + + /** minimal constructor */ + public BaseRelatedTerm(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Short relatedTermType) { + super(deleted, analyticalNotes, translations, meta); + this.relatedTermType = relatedTermType; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.String getRelatedTerm() { + return this.relatedTerm; + } + + public void setRelatedTerm(java.lang.String relatedTerm) { + this.relatedTerm = relatedTerm; + } + + public java.lang.Short getRelatedTermType() { + return this.relatedTermType; + } + + public void setRelatedTermType(java.lang.Short relatedTermType) { + this.relatedTermType = relatedTermType; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseSpeechRegister.java b/src/java/org/thdl/lex/component/BaseSpeechRegister.java new file mode 100644 index 0000000..9e5e74d --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseSpeechRegister.java @@ -0,0 +1,80 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseSpeechRegister extends LexComponent implements org.thdl.lex.component.IRegister,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** persistent field */ + private java.lang.Short register; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseSpeechRegister(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.Short register, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.register = register; + this.parent = parent; + } + + /** default constructor */ + public BaseSpeechRegister() { + } + + /** minimal constructor */ + public BaseSpeechRegister(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Short register) { + super(deleted, analyticalNotes, translations, meta); + this.register = register; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.Short getRegister() { + return this.register; + } + + public void setRegister(java.lang.Short register) { + this.register = register; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseSpelling.java b/src/java/org/thdl/lex/component/BaseSpelling.java new file mode 100644 index 0000000..ee94ab3 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseSpelling.java @@ -0,0 +1,93 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseSpelling extends LexComponent implements Serializable,org.thdl.lex.component.ISpelling { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** persistent field */ + private java.lang.String spelling; + + /** persistent field */ + private java.lang.Short spellingType; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseSpelling(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.String spelling, java.lang.Short spellingType, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.spelling = spelling; + this.spellingType = spellingType; + this.parent = parent; + } + + /** default constructor */ + public BaseSpelling() { + } + + /** minimal constructor */ + public BaseSpelling(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.String spelling, java.lang.Short spellingType) { + super(deleted, analyticalNotes, translations, meta); + this.spelling = spelling; + this.spellingType = spellingType; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.String getSpelling() { + return this.spelling; + } + + public void setSpelling(java.lang.String spelling) { + this.spelling = spelling; + } + + public java.lang.Short getSpellingType() { + return this.spellingType; + } + + public void setSpellingType(java.lang.Short spellingType) { + this.spellingType = spellingType; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseSubdefinition.java b/src/java/org/thdl/lex/component/BaseSubdefinition.java new file mode 100644 index 0000000..05a731d --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseSubdefinition.java @@ -0,0 +1,170 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseSubdefinition extends LexComponent implements org.thdl.lex.component.ISubdefinition,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** nullable persistent field */ + private java.lang.String subdefinition; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** persistent field */ + private List glosses; + + /** persistent field */ + private List keywords; + + /** persistent field */ + private List modelSentences; + + /** persistent field */ + private List translationEquivalents; + + /** persistent field */ + private List relatedTerms; + + /** persistent field */ + private List passages; + + /** persistent field */ + private List registers; + + /** full constructor */ + public BaseSubdefinition(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.String subdefinition, org.thdl.lex.component.ILexComponent parent, List glosses, List keywords, List modelSentences, List translationEquivalents, List relatedTerms, List passages, List registers) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.subdefinition = subdefinition; + this.parent = parent; + this.glosses = glosses; + this.keywords = keywords; + this.modelSentences = modelSentences; + this.translationEquivalents = translationEquivalents; + this.relatedTerms = relatedTerms; + this.passages = passages; + this.registers = registers; + } + + /** default constructor */ + public BaseSubdefinition() { + } + + /** minimal constructor */ + public BaseSubdefinition(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, List glosses, List keywords, List modelSentences, List translationEquivalents, List relatedTerms, List passages, List registers) { + super(deleted, analyticalNotes, translations, meta); + this.glosses = glosses; + this.keywords = keywords; + this.modelSentences = modelSentences; + this.translationEquivalents = translationEquivalents; + this.relatedTerms = relatedTerms; + this.passages = passages; + this.registers = registers; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.String getSubdefinition() { + return this.subdefinition; + } + + public void setSubdefinition(java.lang.String subdefinition) { + this.subdefinition = subdefinition; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public java.util.List getGlosses() { + return this.glosses; + } + + public void setGlosses(java.util.List glosses) { + this.glosses = glosses; + } + + public java.util.List getKeywords() { + return this.keywords; + } + + public void setKeywords(java.util.List keywords) { + this.keywords = keywords; + } + + public java.util.List getModelSentences() { + return this.modelSentences; + } + + public void setModelSentences(java.util.List modelSentences) { + this.modelSentences = modelSentences; + } + + public java.util.List getTranslationEquivalents() { + return this.translationEquivalents; + } + + public void setTranslationEquivalents(java.util.List translationEquivalents) { + this.translationEquivalents = translationEquivalents; + } + + public java.util.List getRelatedTerms() { + return this.relatedTerms; + } + + public void setRelatedTerms(java.util.List relatedTerms) { + this.relatedTerms = relatedTerms; + } + + public java.util.List getPassages() { + return this.passages; + } + + public void setPassages(java.util.List passages) { + this.passages = passages; + } + + public java.util.List getRegisters() { + return this.registers; + } + + public void setRegisters(java.util.List registers) { + this.registers = registers; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseTerm.java b/src/java/org/thdl/lex/component/BaseTerm.java new file mode 100644 index 0000000..a5d0f32 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseTerm.java @@ -0,0 +1,238 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseTerm extends LexComponent implements org.thdl.lex.component.ITerm,Serializable { + + /** persistent field */ + private java.lang.String term; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** persistent field */ + private List pronunciations; + + /** persistent field */ + private List etymologies; + + /** persistent field */ + private List spellings; + + /** persistent field */ + private List functions; + + /** persistent field */ + private List encyclopediaArticles; + + /** persistent field */ + private List transitionalData; + + /** persistent field */ + private List definitions; + + /** persistent field */ + private List glosses; + + /** persistent field */ + private List keywords; + + /** persistent field */ + private List modelSentences; + + /** persistent field */ + private List translationEquivalents; + + /** persistent field */ + private List relatedTerms; + + /** persistent field */ + private List passages; + + /** persistent field */ + private List registers; + + /** full constructor */ + public BaseTerm(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.String term, java.lang.Short precedence, List pronunciations, List etymologies, List spellings, List functions, List encyclopediaArticles, List transitionalData, List definitions, List glosses, List keywords, List modelSentences, List translationEquivalents, List relatedTerms, List passages, List registers) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.term = term; + this.precedence = precedence; + this.pronunciations = pronunciations; + this.etymologies = etymologies; + this.spellings = spellings; + this.functions = functions; + this.encyclopediaArticles = encyclopediaArticles; + this.transitionalData = transitionalData; + this.definitions = definitions; + this.glosses = glosses; + this.keywords = keywords; + this.modelSentences = modelSentences; + this.translationEquivalents = translationEquivalents; + this.relatedTerms = relatedTerms; + this.passages = passages; + this.registers = registers; + } + + /** default constructor */ + public BaseTerm() { + } + + /** minimal constructor */ + public BaseTerm(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.String term, List pronunciations, List etymologies, List spellings, List functions, List encyclopediaArticles, List transitionalData, List definitions, List glosses, List keywords, List modelSentences, List translationEquivalents, List relatedTerms, List passages, List registers) { + super(deleted, analyticalNotes, translations, meta); + this.term = term; + this.pronunciations = pronunciations; + this.etymologies = etymologies; + this.spellings = spellings; + this.functions = functions; + this.encyclopediaArticles = encyclopediaArticles; + this.transitionalData = transitionalData; + this.definitions = definitions; + this.glosses = glosses; + this.keywords = keywords; + this.modelSentences = modelSentences; + this.translationEquivalents = translationEquivalents; + this.relatedTerms = relatedTerms; + this.passages = passages; + this.registers = registers; + } + + public java.lang.String getTerm() { + return this.term; + } + + public void setTerm(java.lang.String term) { + this.term = term; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.util.List getPronunciations() { + return this.pronunciations; + } + + public void setPronunciations(java.util.List pronunciations) { + this.pronunciations = pronunciations; + } + + public java.util.List getEtymologies() { + return this.etymologies; + } + + public void setEtymologies(java.util.List etymologies) { + this.etymologies = etymologies; + } + + public java.util.List getSpellings() { + return this.spellings; + } + + public void setSpellings(java.util.List spellings) { + this.spellings = spellings; + } + + public java.util.List getFunctions() { + return this.functions; + } + + public void setFunctions(java.util.List functions) { + this.functions = functions; + } + + public java.util.List getEncyclopediaArticles() { + return this.encyclopediaArticles; + } + + public void setEncyclopediaArticles(java.util.List encyclopediaArticles) { + this.encyclopediaArticles = encyclopediaArticles; + } + + public java.util.List getTransitionalData() { + return this.transitionalData; + } + + public void setTransitionalData(java.util.List transitionalData) { + this.transitionalData = transitionalData; + } + + public java.util.List getDefinitions() { + return this.definitions; + } + + public void setDefinitions(java.util.List definitions) { + this.definitions = definitions; + } + + public java.util.List getGlosses() { + return this.glosses; + } + + public void setGlosses(java.util.List glosses) { + this.glosses = glosses; + } + + public java.util.List getKeywords() { + return this.keywords; + } + + public void setKeywords(java.util.List keywords) { + this.keywords = keywords; + } + + public java.util.List getModelSentences() { + return this.modelSentences; + } + + public void setModelSentences(java.util.List modelSentences) { + this.modelSentences = modelSentences; + } + + public java.util.List getTranslationEquivalents() { + return this.translationEquivalents; + } + + public void setTranslationEquivalents(java.util.List translationEquivalents) { + this.translationEquivalents = translationEquivalents; + } + + public java.util.List getRelatedTerms() { + return this.relatedTerms; + } + + public void setRelatedTerms(java.util.List relatedTerms) { + this.relatedTerms = relatedTerms; + } + + public java.util.List getPassages() { + return this.passages; + } + + public void setPassages(java.util.List passages) { + this.passages = passages; + } + + public java.util.List getRegisters() { + return this.registers; + } + + public void setRegisters(java.util.List registers) { + this.registers = registers; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseTransitionalData.java b/src/java/org/thdl/lex/component/BaseTransitionalData.java new file mode 100644 index 0000000..716a352 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseTransitionalData.java @@ -0,0 +1,104 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseTransitionalData extends LexComponent implements org.thdl.lex.component.ITransitionalData,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** nullable persistent field */ + private java.lang.Short transitionalDataLabel; + + /** persistent field */ + private java.lang.String forPublicConsumption; + + /** nullable persistent field */ + private java.lang.String transitionalDataText; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseTransitionalData(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.Short transitionalDataLabel, java.lang.String forPublicConsumption, java.lang.String transitionalDataText, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.transitionalDataLabel = transitionalDataLabel; + this.forPublicConsumption = forPublicConsumption; + this.transitionalDataText = transitionalDataText; + this.parent = parent; + } + + /** default constructor */ + public BaseTransitionalData() { + } + + /** minimal constructor */ + public BaseTransitionalData(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.String forPublicConsumption) { + super(deleted, analyticalNotes, translations, meta); + this.forPublicConsumption = forPublicConsumption; + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.Short getTransitionalDataLabel() { + return this.transitionalDataLabel; + } + + public void setTransitionalDataLabel(java.lang.Short transitionalDataLabel) { + this.transitionalDataLabel = transitionalDataLabel; + } + + public java.lang.String getForPublicConsumption() { + return this.forPublicConsumption; + } + + public void setForPublicConsumption(java.lang.String forPublicConsumption) { + this.forPublicConsumption = forPublicConsumption; + } + + public java.lang.String getTransitionalDataText() { + return this.transitionalDataText; + } + + public void setTransitionalDataText(java.lang.String transitionalDataText) { + this.transitionalDataText = transitionalDataText; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/BaseTranslationEquivalent.java b/src/java/org/thdl/lex/component/BaseTranslationEquivalent.java new file mode 100644 index 0000000..ff16742 --- /dev/null +++ b/src/java/org/thdl/lex/component/BaseTranslationEquivalent.java @@ -0,0 +1,79 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import java.util.List; +import java.util.Set; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +abstract public class BaseTranslationEquivalent extends LexComponent implements org.thdl.lex.component.ITranslationEquivalent,Serializable { + + /** nullable persistent field */ + private java.lang.Integer parentId; + + /** nullable persistent field */ + private java.lang.Short precedence; + + /** nullable persistent field */ + private java.lang.String translationEquivalent; + + /** nullable persistent field */ + private org.thdl.lex.component.ILexComponent parent; + + /** full constructor */ + public BaseTranslationEquivalent(java.lang.Integer translationOf, java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta, java.lang.Integer parentId, java.lang.Short precedence, java.lang.String translationEquivalent, org.thdl.lex.component.ILexComponent parent) { + super(translationOf, deleted, analyticalNotes, translations, meta); + this.parentId = parentId; + this.precedence = precedence; + this.translationEquivalent = translationEquivalent; + this.parent = parent; + } + + /** default constructor */ + public BaseTranslationEquivalent() { + } + + /** minimal constructor */ + public BaseTranslationEquivalent(java.lang.Boolean deleted, List analyticalNotes, Set translations, org.thdl.lex.component.Meta meta) { + super(deleted, analyticalNotes, translations, meta); + } + + public java.lang.Integer getParentId() { + return this.parentId; + } + + public void setParentId(java.lang.Integer parentId) { + this.parentId = parentId; + } + + public java.lang.Short getPrecedence() { + return this.precedence; + } + + public void setPrecedence(java.lang.Short precedence) { + this.precedence = precedence; + } + + public java.lang.String getTranslationEquivalent() { + return this.translationEquivalent; + } + + public void setTranslationEquivalent(java.lang.String translationEquivalent) { + this.translationEquivalent = translationEquivalent; + } + + public org.thdl.lex.component.ILexComponent getParent() { + return this.parent; + } + + public void setParent(org.thdl.lex.component.ILexComponent parent) { + this.parent = parent; + } + + public String toString() { + return new ToStringBuilder(this) + .append("metaId", getMetaId()) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/Definition.java b/src/java/org/thdl/lex/component/Definition.java new file mode 100644 index 0000000..953ec7d --- /dev/null +++ b/src/java/org/thdl/lex/component/Definition.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class Definition extends BaseDefinition implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/EncyclopediaArticle.java b/src/java/org/thdl/lex/component/EncyclopediaArticle.java new file mode 100644 index 0000000..a4f8b6f --- /dev/null +++ b/src/java/org/thdl/lex/component/EncyclopediaArticle.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class EncyclopediaArticle extends BaseEncyclopediaArticle implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/Etymology.java b/src/java/org/thdl/lex/component/Etymology.java new file mode 100644 index 0000000..0da9a03 --- /dev/null +++ b/src/java/org/thdl/lex/component/Etymology.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class Etymology extends BaseEtymology implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/Gloss.java b/src/java/org/thdl/lex/component/Gloss.java new file mode 100644 index 0000000..b51089e --- /dev/null +++ b/src/java/org/thdl/lex/component/Gloss.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class Gloss extends BaseGloss implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/GrammaticalFunction.java b/src/java/org/thdl/lex/component/GrammaticalFunction.java new file mode 100644 index 0000000..07ad5a6 --- /dev/null +++ b/src/java/org/thdl/lex/component/GrammaticalFunction.java @@ -0,0 +1,16 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + + +/** + * Description of the Class + * + * @author travis + * @created October 5, 2003 + */ +public class GrammaticalFunction extends BaseGrammaticalFunction implements Serializable +{ + +} + diff --git a/src/java/org/thdl/lex/component/IAnalyticalNote.java b/src/java/org/thdl/lex/component/IAnalyticalNote.java new file mode 100644 index 0000000..251b5f3 --- /dev/null +++ b/src/java/org/thdl/lex/component/IAnalyticalNote.java @@ -0,0 +1,65 @@ +package org.thdl.lex.component; + + +/** + * Description of the Interface + * + *@author travis + *@created October 3, 2003 + */ +public interface IAnalyticalNote extends ILexComponent +{ + /** + * Gets the parent attribute of the IAnalyticalNote object + * + *@return The parent value + *@since + */ + public ILexComponent getParent(); + + + /** + * Sets the parent attribute of the IAnalyticalNote object + * + *@param comp The new parent value + *@since + */ + public void setParent( ILexComponent comp ); + + + /** + * Gets the parentId attribute of the IAnalyticalNote object + * + *@return The parentId value + *@since + */ + public java.lang.Integer getParentId(); + + + /** + * Sets the parentId attribute of the IAnalyticalNote object + * + *@param parentId The new parentId value + *@since + */ + public void setParentId( java.lang.Integer parentId ); + + + /** + * Gets the analyticalNote attribute of the IAnalyticalNote object + * + *@return The analyticalNote value + *@since + */ + public java.lang.String getAnalyticalNote(); + + + /** + * Sets the analyticalNote attribute of the IAnalyticalNote object + * + *@param analyticalNote The new analyticalNote value + *@since + */ + public void setAnalyticalNote( java.lang.String analyticalNote ); +} + diff --git a/src/java/org/thdl/lex/component/IDefinition.java b/src/java/org/thdl/lex/component/IDefinition.java new file mode 100644 index 0000000..9dc2bf6 --- /dev/null +++ b/src/java/org/thdl/lex/component/IDefinition.java @@ -0,0 +1,194 @@ +package org.thdl.lex.component; + + +/** + * Description of the Interface + * + *@author travis + *@created October 1, 2003 + */ +public interface IDefinition extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + /** + * Gets the definition attribute of the IDefinition object + * + *@return The definition value + *@since + */ + public java.lang.String getDefinition(); + + + /** + * Sets the definition attribute of the IDefinition object + * + *@param definition The new definition value + *@since + */ + public void setDefinition( java.lang.String definition ); + + + /** + * Gets the precedence attribute of the IDefinition object + * + *@return The precedence value + *@since + */ + public java.lang.Short getPrecedence(); + + + /** + * Sets the precedence attribute of the IDefinition object + * + *@param precedence The new precedence value + *@since + */ + public void setPrecedence( java.lang.Short precedence ); + + + /** + * Gets the subdefinitions attribute of the IDefinition object + * + *@return The subdefinitions value + *@since + */ + public java.util.List getSubdefinitions(); + + + /** + * Sets the subdefinitions attribute of the IDefinition object + * + *@param subdefinitions The new subdefinitions value + *@since + */ + public void setSubdefinitions( java.util.List subdefinitions ); + + + /** + * Gets the glosses attribute of the IDefinition object + * + *@return The glosses value + *@since + */ + public java.util.List getGlosses(); + + + /** + * Sets the glosses attribute of the IDefinition object + * + *@param glosses The new glosses value + *@since + */ + public void setGlosses( java.util.List glosses ); + + + /** + * Gets the keywords attribute of the IDefinition object + * + *@return The keywords value + *@since + */ + public java.util.List getKeywords(); + + + /** + * Sets the keywords attribute of the IDefinition object + * + *@param keywords The new keywords value + *@since + */ + public void setKeywords( java.util.List keywords ); + + + /** + * Gets the modelSentences attribute of the IDefinition object + * + *@return The modelSentences value + *@since + */ + public java.util.List getModelSentences(); + + + /** + * Sets the modelSentences attribute of the IDefinition object + * + *@param modelSentences The new modelSentences value + *@since + */ + public void setModelSentences( java.util.List modelSentences ); + + + /** + * Gets the translationEquivalents attribute of the IDefinition object + * + *@return The translationEquivalents value + *@since + */ + public java.util.List getTranslationEquivalents(); + + + /** + * Sets the translationEquivalents attribute of the IDefinition object + * + *@param translationEquivalents The new translationEquivalents value + *@since + */ + public void setTranslationEquivalents( java.util.List translationEquivalents ); + + + /** + * Gets the relatedTerms attribute of the IDefinition object + * + *@return The relatedTerms value + *@since + */ + public java.util.List getRelatedTerms(); + + + /** + * Sets the relatedTerms attribute of the IDefinition object + * + *@param relatedTerms The new relatedTerms value + *@since + */ + public void setRelatedTerms( java.util.List relatedTerms ); + + + /** + * Gets the passages attribute of the IDefinition object + * + *@return The passages value + *@since + */ + public java.util.List getPassages(); + + + /** + * Sets the passages attribute of the IDefinition object + * + *@param passages The new passages value + *@since + */ + public void setPassages( java.util.List passages ); + + + /** + * Gets the registers attribute of the IDefinition object + * + *@return The registers value + *@since + */ + public java.util.List getRegisters(); + + + /** + * Sets the registers attribute of the IDefinition object + * + *@param registers The new registers value + *@since + */ + public void setRegisters( java.util.List registers ); +} + diff --git a/src/java/org/thdl/lex/component/IEncyclopediaArticle.java b/src/java/org/thdl/lex/component/IEncyclopediaArticle.java new file mode 100644 index 0000000..a3e0b47 --- /dev/null +++ b/src/java/org/thdl/lex/component/IEncyclopediaArticle.java @@ -0,0 +1,13 @@ +package org.thdl.lex.component; + +public interface IEncyclopediaArticle extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.String getArticle(); + public void setArticle(java.lang.String article); + public java.lang.String getArticleTitle(); + public void setArticleTitle(java.lang.String articleTitle); +} + diff --git a/src/java/org/thdl/lex/component/IEtymology.java b/src/java/org/thdl/lex/component/IEtymology.java new file mode 100644 index 0000000..28599c1 --- /dev/null +++ b/src/java/org/thdl/lex/component/IEtymology.java @@ -0,0 +1,17 @@ +package org.thdl.lex.component; + +public interface IEtymology extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.Short getLoanLanguage(); + public void setLoanLanguage(java.lang.Short loanLanguage); + public java.lang.Short getEtymologyType(); + public void setEtymologyType(java.lang.Short etymologyType); + public java.lang.String getDerivation(); + public void setDerivation(java.lang.String derivation); + public java.lang.String getEtymologyDescription(); + public void setEtymologyDescription(java.lang.String etymologyDescription); +} + diff --git a/src/java/org/thdl/lex/component/IFunction.java b/src/java/org/thdl/lex/component/IFunction.java new file mode 100644 index 0000000..5e6b16e --- /dev/null +++ b/src/java/org/thdl/lex/component/IFunction.java @@ -0,0 +1,11 @@ +package org.thdl.lex.component; + +public interface IFunction extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.Short getFunction(); + public void setFunction(java.lang.Short function); +} + diff --git a/src/java/org/thdl/lex/component/IGloss.java b/src/java/org/thdl/lex/component/IGloss.java new file mode 100644 index 0000000..990e5c9 --- /dev/null +++ b/src/java/org/thdl/lex/component/IGloss.java @@ -0,0 +1,13 @@ +package org.thdl.lex.component; + +public interface IGloss extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.String getGloss(); + public void setGloss(java.lang.String gloss); + public java.lang.String getTranslation(); + public void setTranslation(java.lang.String translation); +} + diff --git a/src/java/org/thdl/lex/component/IKeyword.java b/src/java/org/thdl/lex/component/IKeyword.java new file mode 100644 index 0000000..ef79f2a --- /dev/null +++ b/src/java/org/thdl/lex/component/IKeyword.java @@ -0,0 +1,12 @@ +package org.thdl.lex.component; + +public interface IKeyword extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.String getKeyword(); + public void setKeyword(java.lang.String keyword); +} + + diff --git a/src/java/org/thdl/lex/component/ILexComponent.java b/src/java/org/thdl/lex/component/ILexComponent.java new file mode 100644 index 0000000..53ea18a --- /dev/null +++ b/src/java/org/thdl/lex/component/ILexComponent.java @@ -0,0 +1,148 @@ +package org.thdl.lex.component; + + +/** + * Description of the Interface + * + *@author travis + *@created October 1, 2003 + */ +public interface ILexComponent +{ + + /** + * Gets the label attribute of the ILexComponent object + * + *@return The label value + *@since + */ + public java.lang.String getLabel(); + + + /** + * Sets the label attribute of the ILexComponent object + * + *@param label The new label value + *@since + */ + public void setLabel( java.lang.String label ); + + + /** + * Gets the metaId attribute of the ILexComponent object + * + *@return The metaId value + *@since + */ + public java.lang.Integer getMetaId(); + + + /** + * Sets the metaId attribute of the ILexComponent object + * + *@param metaId The new metaId value + *@since + */ + public void setMetaId( java.lang.Integer metaId ); + + + /** + * Gets the translationOf attribute of the ILexComponent object + * + *@return The translationOf value + *@since + */ + public java.lang.Integer getTranslationOf(); + + + /** + * Sets the translationOf attribute of the ILexComponent object + * + *@param translationOf The new translationOf value + *@since + */ + public void setTranslationOf( java.lang.Integer translationOf ); + + + /** + * Gets the translations attribute of the ILexComponent object + * + *@return The translations value + *@since + */ + public java.util.Set getTranslations(); + + + /** + * Sets the translations attribute of the ILexComponent object + * + *@param translations The new translations value + *@since + */ + public void setTranslations( java.util.Set translations ); + + + /** + * Gets the deleted attribute of the ILexComponent object + * + *@return The deleted value + *@since + */ + public java.lang.Boolean getDeleted(); + + + /** + * Sets the deleted attribute of the ILexComponent object + * + *@param deleted The new deleted value + *@since + */ + public void setDeleted( java.lang.Boolean deleted ); + + + /** + * Gets the analyticalNotes attribute of the ILexComponent object + * + *@return The analyticalNotes value + *@since + */ + public java.util.List getAnalyticalNotes(); + + + /** + * Sets the analyticalNotes attribute of the ILexComponent object + * + *@param analyticalNotes The new analyticalNotes value + *@since + */ + public void setAnalyticalNotes( java.util.List analyticalNotes ); + + + /** + * Gets the meta attribute of the ILexComponent object + * + *@return The meta value + *@since + */ + public org.thdl.lex.component.Meta getMeta(); + + + /** + * Sets the meta attribute of the ILexComponent object + * + *@param meta The new meta value + *@since + */ + public void setMeta( org.thdl.lex.component.Meta meta ); + + + /** + * Description of the Method + * + *@param properties Description of Parameter + *@exception LexComponentException Description of Exception + *@since + */ + public void populate( java.util.Map properties ) throws LexComponentException; +} + diff --git a/src/java/org/thdl/lex/component/IMeta.java b/src/java/org/thdl/lex/component/IMeta.java new file mode 100644 index 0000000..98b9552 --- /dev/null +++ b/src/java/org/thdl/lex/component/IMeta.java @@ -0,0 +1,31 @@ +package org.thdl.lex.component; + +public interface IMeta extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.Integer getCreatedBy(); + public void setCreatedBy(java.lang.Integer createdBy); + public java.lang.Integer getModifiedBy(); + public void setModifiedBy(java.lang.Integer modifiedBy); + public java.lang.Integer getCreatedByProjSub(); + public void setCreatedByProjSub(java.lang.Integer createdByProjSub); + public java.lang.Integer getModifiedByProjSub(); + public void setModifiedByProjSub(java.lang.Integer modifiedByProjSub); + public java.util.Date getCreatedOn(); + public void setCreatedOn(java.util.Date createdOn); + public java.util.Date getModifiedOn(); + public void setModifiedOn(java.util.Date modifiedOn); + public java.lang.Integer getSource(); + public void setSource(java.lang.Integer source); + public java.lang.Short getLanguage(); + public void setLanguage(java.lang.Short language); + public java.lang.Short getScript(); + public void setScript(java.lang.Short script); + public java.lang.Short getDialect(); + public void setDialect(java.lang.Short dialect); + public java.lang.String getNote(); + public void setNote(java.lang.String note); +} + diff --git a/src/java/org/thdl/lex/component/IModelSentence.java b/src/java/org/thdl/lex/component/IModelSentence.java new file mode 100644 index 0000000..e672662 --- /dev/null +++ b/src/java/org/thdl/lex/component/IModelSentence.java @@ -0,0 +1,13 @@ +package org.thdl.lex.component; + +public interface IModelSentence extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.Integer getSubdefinitionId(); + public void setSubdefinitionId(java.lang.Integer subdefinitionId); + public java.lang.String getModelSentence(); + public void setModelSentence(java.lang.String modelSentence); +} + diff --git a/src/java/org/thdl/lex/component/IPassage.java b/src/java/org/thdl/lex/component/IPassage.java new file mode 100644 index 0000000..06f00ad --- /dev/null +++ b/src/java/org/thdl/lex/component/IPassage.java @@ -0,0 +1,17 @@ +package org.thdl.lex.component; + +public interface IPassage extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.String getLiterarySource(); + public void setLiterarySource(java.lang.String literarySource); + public java.lang.String getSpelling(); + public void setSpelling(java.lang.String spelling); + public java.lang.String getPagination(); + public void setPagination(java.lang.String pagination); + public java.lang.String getPassage(); + public void setPassage(java.lang.String passage); +} + diff --git a/src/java/org/thdl/lex/component/IPronunciation.java b/src/java/org/thdl/lex/component/IPronunciation.java new file mode 100644 index 0000000..be754dd --- /dev/null +++ b/src/java/org/thdl/lex/component/IPronunciation.java @@ -0,0 +1,13 @@ +package org.thdl.lex.component; + +public interface IPronunciation extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.String getPhonetics(); + public void setPhonetics(java.lang.String phonetics); + public java.lang.Short getPhoneticsType(); + public void setPhoneticsType(java.lang.Short phoneticsType); +} + diff --git a/src/java/org/thdl/lex/component/IRegister.java b/src/java/org/thdl/lex/component/IRegister.java new file mode 100644 index 0000000..3d7fd87 --- /dev/null +++ b/src/java/org/thdl/lex/component/IRegister.java @@ -0,0 +1,11 @@ +package org.thdl.lex.component; + +public interface IRegister extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.Short getRegister(); + public void setRegister(java.lang.Short register); +} + diff --git a/src/java/org/thdl/lex/component/IRelatedTerm.java b/src/java/org/thdl/lex/component/IRelatedTerm.java new file mode 100644 index 0000000..2026717 --- /dev/null +++ b/src/java/org/thdl/lex/component/IRelatedTerm.java @@ -0,0 +1,13 @@ +package org.thdl.lex.component; + +public interface IRelatedTerm extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.String getRelatedTerm(); + public void setRelatedTerm(java.lang.String relatedTerm); + public java.lang.Short getRelatedTermType(); + public void setRelatedTermType(java.lang.Short relatedTermType); +} + diff --git a/src/java/org/thdl/lex/component/ISpelling.java b/src/java/org/thdl/lex/component/ISpelling.java new file mode 100644 index 0000000..cd8cae2 --- /dev/null +++ b/src/java/org/thdl/lex/component/ISpelling.java @@ -0,0 +1,13 @@ +package org.thdl.lex.component; + +public interface ISpelling extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.String getSpelling(); + public void setSpelling(java.lang.String spelling); + public java.lang.Short getSpellingType(); + public void setSpellingType(java.lang.Short spellingType); +} + diff --git a/src/java/org/thdl/lex/component/ISubdefinition.java b/src/java/org/thdl/lex/component/ISubdefinition.java new file mode 100644 index 0000000..63a88aa --- /dev/null +++ b/src/java/org/thdl/lex/component/ISubdefinition.java @@ -0,0 +1,25 @@ +package org.thdl.lex.component; + +public interface ISubdefinition extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.String getSubdefinition(); + public void setSubdefinition(java.lang.String subdefinition); + public java.util.List getGlosses(); + public void setGlosses(java.util.List glosses); + public java.util.List getKeywords(); + public void setKeywords(java.util.List keywords); + public java.util.List getModelSentences(); + public void setModelSentences(java.util.List modelSentences); + public java.util.List getTranslationEquivalents(); + public void setTranslationEquivalents(java.util.List translationEquivalents); + public java.util.List getRelatedTerms(); + public void setRelatedTerms(java.util.List relatedTerms); + public java.util.List getPassages(); + public void setPassages(java.util.List passages); + public java.util.List getRegisters(); + public void setRegisters(java.util.List registers); +} + diff --git a/src/java/org/thdl/lex/component/ITerm.java b/src/java/org/thdl/lex/component/ITerm.java new file mode 100644 index 0000000..8670ce7 --- /dev/null +++ b/src/java/org/thdl/lex/component/ITerm.java @@ -0,0 +1,299 @@ +package org.thdl.lex.component; + + +/** + * Description of the Interface + * + *@author travis + *@created October 1, 2003 + */ +public interface ITerm extends ILexComponent +{ + /** + * Gets the term attribute of the ITerm object + * + *@return The term value + *@since + */ + public java.lang.String getTerm(); + + + /** + * Sets the term attribute of the ITerm object + * + *@param term The new term value + *@since + */ + public void setTerm( java.lang.String term ); + + + /** + * Gets the precedence attribute of the ITerm object + * + *@return The precedence value + *@since + */ + public java.lang.Short getPrecedence(); + + + /** + * Sets the precedence attribute of the ITerm object + * + *@param precedence The new precedence value + *@since + */ + public void setPrecedence( java.lang.Short precedence ); + + + /** + * Gets the pronunciations attribute of the ITerm object + * + *@return The pronunciations value + *@since + */ + public java.util.List getPronunciations(); + + + /** + * Sets the pronunciations attribute of the ITerm object + * + *@param pronunciations The new pronunciations value + *@since + */ + public void setPronunciations( java.util.List pronunciations ); + + + /** + * Gets the etymologies attribute of the ITerm object + * + *@return The etymologies value + *@since + */ + public java.util.List getEtymologies(); + + + /** + * Sets the etymologies attribute of the ITerm object + * + *@param etymologies The new etymologies value + *@since + */ + public void setEtymologies( java.util.List etymologies ); + + + /** + * Gets the spellings attribute of the ITerm object + * + *@return The spellings value + *@since + */ + public java.util.List getSpellings(); + + + /** + * Sets the spellings attribute of the ITerm object + * + *@param spellings The new spellings value + *@since + */ + public void setSpellings( java.util.List spellings ); + + + /** + * Gets the functions attribute of the ITerm object + * + *@return The functions value + *@since + */ + public java.util.List getFunctions(); + + + /** + * Sets the functions attribute of the ITerm object + * + *@param functions The new functions value + *@since + */ + public void setFunctions( java.util.List functions ); + + + /** + * Gets the encyclopediaArticles attribute of the ITerm object + * + *@return The encyclopediaArticles value + *@since + */ + public java.util.List getEncyclopediaArticles(); + + + /** + * Sets the encyclopediaArticles attribute of the ITerm object + * + *@param encyclopediaArticles The new encyclopediaArticles value + *@since + */ + public void setEncyclopediaArticles( java.util.List encyclopediaArticles ); + + + /** + * Gets the transitionalData attribute of the ITerm object + * + *@return The transitionalData value + *@since + */ + public java.util.List getTransitionalData(); + + + /** + * Sets the transitionalData attribute of the ITerm object + * + *@param transitionalData The new transitionalData value + *@since + */ + public void setTransitionalData( java.util.List transitionalData ); + + + /** + * Gets the definitions attribute of the ITerm object + * + *@return The definitions value + *@since + */ + public java.util.List getDefinitions(); + + + /** + * Sets the definitions attribute of the ITerm object + * + *@param definitions The new definitions value + *@since + */ + public void setDefinitions( java.util.List definitions ); + + + /** + * Gets the glosses attribute of the ITerm object + * + *@return The glosses value + *@since + */ + public java.util.List getGlosses(); + + + /** + * Sets the glosses attribute of the ITerm object + * + *@param glosses The new glosses value + *@since + */ + public void setGlosses( java.util.List glosses ); + + + /** + * Gets the keywords attribute of the ITerm object + * + *@return The keywords value + *@since + */ + public java.util.List getKeywords(); + + + /** + * Sets the keywords attribute of the ITerm object + * + *@param keywords The new keywords value + *@since + */ + public void setKeywords( java.util.List keywords ); + + + /** + * Gets the modelSentences attribute of the ITerm object + * + *@return The modelSentences value + *@since + */ + public java.util.List getModelSentences(); + + + /** + * Sets the modelSentences attribute of the ITerm object + * + *@param modelSentences The new modelSentences value + *@since + */ + public void setModelSentences( java.util.List modelSentences ); + + + /** + * Gets the translationEquivalents attribute of the ITerm object + * + *@return The translationEquivalents value + *@since + */ + public java.util.List getTranslationEquivalents(); + + + /** + * Sets the translationEquivalents attribute of the ITerm object + * + *@param translationEquivalents The new translationEquivalents value + *@since + */ + public void setTranslationEquivalents( java.util.List translationEquivalents ); + + + /** + * Gets the relatedTerms attribute of the ITerm object + * + *@return The relatedTerms value + *@since + */ + public java.util.List getRelatedTerms(); + + + /** + * Sets the relatedTerms attribute of the ITerm object + * + *@param relatedTerms The new relatedTerms value + *@since + */ + public void setRelatedTerms( java.util.List relatedTerms ); + + + /** + * Gets the passages attribute of the ITerm object + * + *@return The passages value + *@since + */ + public java.util.List getPassages(); + + + /** + * Sets the passages attribute of the ITerm object + * + *@param passages The new passages value + *@since + */ + public void setPassages( java.util.List passages ); + + + /** + * Gets the registers attribute of the ITerm object + * + *@return The registers value + *@since + */ + public java.util.List getRegisters(); + + + /** + * Sets the registers attribute of the ITerm object + * + *@param registers The new registers value + *@since + */ + public void setRegisters( java.util.List registers ); +} + diff --git a/src/java/org/thdl/lex/component/ITransitionalData.java b/src/java/org/thdl/lex/component/ITransitionalData.java new file mode 100644 index 0000000..43c854a --- /dev/null +++ b/src/java/org/thdl/lex/component/ITransitionalData.java @@ -0,0 +1,15 @@ +package org.thdl.lex.component; + +public interface ITransitionalData extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + public java.lang.Integer getParentId(); + public void setParentId( java.lang.Integer parentId ); + public java.lang.Short getTransitionalDataLabel(); + public void setTransitionalDataLabel(java.lang.Short transitionalDataLabel); + public java.lang.String getForPublicConsumption(); + public void setForPublicConsumption(java.lang.String forPublicConsumption); + public java.lang.String getTransitionalDataText(); + public void setTransitionalDataText(java.lang.String transitionalDataText); +} + diff --git a/src/java/org/thdl/lex/component/ITranslationEquivalent.java b/src/java/org/thdl/lex/component/ITranslationEquivalent.java new file mode 100644 index 0000000..543f007 --- /dev/null +++ b/src/java/org/thdl/lex/component/ITranslationEquivalent.java @@ -0,0 +1,32 @@ +package org.thdl.lex.component; + + +/** + * Description of the Interface + * + *@author travis + *@created October 3, 2003 + */ +public interface ITranslationEquivalent extends ILexComponent +{ public ILexComponent getParent(); + public void setParent( ILexComponent comp ); + /** + * Gets the translationEquivalent attribute of the ITranslationEquivalent + * object + * + *@return The translationEquivalent value + *@since + */ + public java.lang.String getTranslationEquivalent(); + + + /** + * Sets the translationEquivalent attribute of the ITranslationEquivalent + * object + * + *@param translationEquivalent The new translationEquivalent value + *@since + */ + public void setTranslationEquivalent( java.lang.String translationEquivalent ); +} + diff --git a/src/java/org/thdl/lex/component/Keyword.java b/src/java/org/thdl/lex/component/Keyword.java new file mode 100644 index 0000000..ea22fe6 --- /dev/null +++ b/src/java/org/thdl/lex/component/Keyword.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class Keyword extends BaseKeyword implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/LexComponent.hbm.xml b/src/java/org/thdl/lex/component/LexComponent.hbm.xml new file mode 100644 index 0000000..1ffcbec --- /dev/null +++ b/src/java/org/thdl/lex/component/LexComponent.hbm.xml @@ -0,0 +1,354 @@ + + + + + + + org.thdl.lex.component.BaseLexComponent + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + org.thdl.lex.component.BaseAnalyticalNote + + + + + + + + + org.thdl.lex.component.BaseTerm + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + org.thdl.lex.component.BaseDefinition + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + org.thdl.lex.component.BaseSubdefinition + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + org.thdl.lex.component.BasePronunciation + + + + + + + + + + org.thdl.lex.component.BaseEtymology + + + + + + + + + + + + org.thdl.lex.component.BaseSpelling + + + + + + + + + + org.thdl.lex.component.BaseGrammaticalFunction + + + + + + + + + org.thdl.lex.component.BaseEncyclopediaArticle + + + + + + + + + + org.thdl.lex.component.BaseGloss + + + + + + + + + + org.thdl.lex.component.BaseKeyword + + + + + + + + + org.thdl.lex.component.BaseModelSentence + + + + + + + + + + org.thdl.lex.component.BaseTranslationEquivalent + + + + + + + + + org.thdl.lex.component.BaseRelatedTerm + + + + + + + + + + org.thdl.lex.component.BasePassage + + + + + + + + + + + + org.thdl.lex.component.BaseSpeechRegister + + + + + + + + + org.thdl.lex.component.BaseTransitionalData + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/LexComponent.java b/src/java/org/thdl/lex/component/LexComponent.java new file mode 100644 index 0000000..cde5674 --- /dev/null +++ b/src/java/org/thdl/lex/component/LexComponent.java @@ -0,0 +1,122 @@ +package org.thdl.lex.component; + +import org.apache.commons.beanutils.BeanUtils; +import java.io.Serializable; +import java.util.*; + + +/** + * Description of the Class + * + *@author travis + *@created October 1, 2003 + */ +// public abstract class LexComponent extends BaseLexComponent implements Serializable +public abstract class LexComponent extends BaseLexComponent implements Serializable +{ + + private String label; + + + /** + * Sets the label attribute of the LexComponent object + * + *@param label The new label value + *@since + */ + public void setLabel( String label ) + { + this.label = label; + } + + + /** + * Gets the label attribute of the LexComponent object + * + *@return The label value + *@since + */ + public String getLabel() + { + if ( null == label ) + { + String labelHex = this.toString(); + int cutoff = labelHex.indexOf( "@" ); + labelHex = labelHex.substring( 0, cutoff ); + labelHex = labelHex + "." + getMetaId(); + labelHex = labelHex.replace( ".".toCharArray()[0], ":".toCharArray()[0] ); + setLabel( labelHex ); + } + return label; + } + + + //helper methods + /** + * Description of the Method + * + *@param properties Description of Parameter + *@exception LexComponentException Description of Exception + *@since + */ + public void populate( Map properties ) throws LexComponentException + { + try + { + BeanUtils.populate( this, properties ); + } + catch ( IllegalAccessException iae ) + { + throw new LexComponentException( iae ); + } + catch ( java.lang.reflect.InvocationTargetException ite ) + { + throw new LexComponentException( ite ); + } + + } + + +//constructors + /** + * Constructor for the LexComponent object + * + *@param translationOf Description of Parameter + *@param deleted Description of Parameter + *@param analyticalNotes Description of Parameter + *@param meta Description of Parameter + *@param translations Description of Parameter + *@since + */ + public LexComponent( Integer translationOf, Boolean deleted, List analyticalNotes, Set translations, Meta meta ) + { + super( translationOf, deleted, analyticalNotes, translations, meta ); + } + + + /** + * Constructor for the LexComponent object + * + *@param deleted Description of Parameter + *@param analyticalNotes Description of Parameter + *@param meta Description of Parameter + *@param translations Description of Parameter + *@since + */ + public LexComponent( Boolean deleted, List analyticalNotes, Set translations, Meta meta ) + { + super( deleted, analyticalNotes, translations, meta ); + } + + + /** + * Constructor for the LexComponent object + * + *@since + */ + public LexComponent() + { + super(); + } +} + diff --git a/src/java/org/thdl/lex/component/LexComponentException.java b/src/java/org/thdl/lex/component/LexComponentException.java new file mode 100644 index 0000000..61b9bf0 --- /dev/null +++ b/src/java/org/thdl/lex/component/LexComponentException.java @@ -0,0 +1,59 @@ +package org.thdl.lex.component; + + +/** + * Description of the Class + * + *@author travis + *@created October 1, 2003 + */ +public class LexComponentException extends Exception +{ + /** + * Constructor for the LexComponentException object + * + *@since + */ + public LexComponentException() + { + super(); + } + + + /** + * Constructor for the LexComponentException object + * + *@param msg Description of Parameter + *@since + */ + public LexComponentException( String msg ) + { + super( msg ); + } + + + /** + * Constructor for the LexComponentException object + * + *@param e Description of Parameter + *@since + */ + public LexComponentException( Exception e ) + { + super( e ); + } + + + /** + * Constructor for the LexComponentException object + * + *@param msg Description of Parameter + *@param e Description of Parameter + *@since + */ + public LexComponentException( String msg, Exception e ) + { + super( msg, e ); + } +} + diff --git a/src/java/org/thdl/lex/component/LexEntryException.java b/src/java/org/thdl/lex/component/LexEntryException.java new file mode 100644 index 0000000..e01f0cf --- /dev/null +++ b/src/java/org/thdl/lex/component/LexEntryException.java @@ -0,0 +1,14 @@ +package org.thdl.lex.component; + +public class LexEntryException extends Exception +{ + public LexEntryException() + { + super(); + } + + public LexEntryException(String msg) + { + super(msg); + } +} diff --git a/src/java/org/thdl/lex/component/Meta.java b/src/java/org/thdl/lex/component/Meta.java new file mode 100644 index 0000000..65f77fa --- /dev/null +++ b/src/java/org/thdl/lex/component/Meta.java @@ -0,0 +1,166 @@ +package org.thdl.lex.component; + +import java.io.Serializable; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class Meta implements Serializable { + + /** persistent field */ + private java.lang.Integer createdBy; + + /** persistent field */ + private java.lang.Integer modifiedBy; + + /** persistent field */ + private java.lang.Integer createdByProjSub; + + /** persistent field */ + private java.lang.Integer modifiedByProjSub; + + /** nullable persistent field */ + private java.util.Date createdOn; + + /** nullable persistent field */ + private java.util.Date modifiedOn; + + /** persistent field */ + private java.lang.Integer source; + + /** persistent field */ + private java.lang.Short language; + + /** persistent field */ + private java.lang.Short script; + + /** persistent field */ + private java.lang.Short dialect; + + /** nullable persistent field */ + private java.lang.String note; + + /** full constructor */ + public Meta(java.lang.Integer createdBy, java.lang.Integer modifiedBy, java.lang.Integer createdByProjSub, java.lang.Integer modifiedByProjSub, java.util.Date createdOn, java.util.Date modifiedOn, java.lang.Integer source, java.lang.Short language, java.lang.Short script, java.lang.Short dialect, java.lang.String note) { + this.createdBy = createdBy; + this.modifiedBy = modifiedBy; + this.createdByProjSub = createdByProjSub; + this.modifiedByProjSub = modifiedByProjSub; + this.createdOn = createdOn; + this.modifiedOn = modifiedOn; + this.source = source; + this.language = language; + this.script = script; + this.dialect = dialect; + this.note = note; + } + + /** default constructor */ + public Meta() { + } + + /** minimal constructor */ + public Meta(java.lang.Integer createdBy, java.lang.Integer modifiedBy, java.lang.Integer createdByProjSub, java.lang.Integer modifiedByProjSub, java.lang.Integer source, java.lang.Short language, java.lang.Short script, java.lang.Short dialect) { + this.createdBy = createdBy; + this.modifiedBy = modifiedBy; + this.createdByProjSub = createdByProjSub; + this.modifiedByProjSub = modifiedByProjSub; + this.source = source; + this.language = language; + this.script = script; + this.dialect = dialect; + } + + public java.lang.Integer getCreatedBy() { + return this.createdBy; + } + + public void setCreatedBy(java.lang.Integer createdBy) { + this.createdBy = createdBy; + } + + public java.lang.Integer getModifiedBy() { + return this.modifiedBy; + } + + public void setModifiedBy(java.lang.Integer modifiedBy) { + this.modifiedBy = modifiedBy; + } + + public java.lang.Integer getCreatedByProjSub() { + return this.createdByProjSub; + } + + public void setCreatedByProjSub(java.lang.Integer createdByProjSub) { + this.createdByProjSub = createdByProjSub; + } + + public java.lang.Integer getModifiedByProjSub() { + return this.modifiedByProjSub; + } + + public void setModifiedByProjSub(java.lang.Integer modifiedByProjSub) { + this.modifiedByProjSub = modifiedByProjSub; + } + + public java.util.Date getCreatedOn() { + return this.createdOn; + } + + public void setCreatedOn(java.util.Date createdOn) { + this.createdOn = createdOn; + } + + public java.util.Date getModifiedOn() { + return this.modifiedOn; + } + + public void setModifiedOn(java.util.Date modifiedOn) { + this.modifiedOn = modifiedOn; + } + + public java.lang.Integer getSource() { + return this.source; + } + + public void setSource(java.lang.Integer source) { + this.source = source; + } + + public java.lang.Short getLanguage() { + return this.language; + } + + public void setLanguage(java.lang.Short language) { + this.language = language; + } + + public java.lang.Short getScript() { + return this.script; + } + + public void setScript(java.lang.Short script) { + this.script = script; + } + + public java.lang.Short getDialect() { + return this.dialect; + } + + public void setDialect(java.lang.Short dialect) { + this.dialect = dialect; + } + + public java.lang.String getNote() { + return this.note; + } + + public void setNote(java.lang.String note) { + this.note = note; + } + + public String toString() { + return new ToStringBuilder(this) + .toString(); + } + +} diff --git a/src/java/org/thdl/lex/component/ModelSentence.java b/src/java/org/thdl/lex/component/ModelSentence.java new file mode 100644 index 0000000..e366115 --- /dev/null +++ b/src/java/org/thdl/lex/component/ModelSentence.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class ModelSentence extends BaseModelSentence implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/Passage.java b/src/java/org/thdl/lex/component/Passage.java new file mode 100644 index 0000000..2e8087f --- /dev/null +++ b/src/java/org/thdl/lex/component/Passage.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class Passage extends BasePassage implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/Pronunciation.java b/src/java/org/thdl/lex/component/Pronunciation.java new file mode 100644 index 0000000..072864b --- /dev/null +++ b/src/java/org/thdl/lex/component/Pronunciation.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class Pronunciation extends BasePronunciation implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/RelatedTerm.java b/src/java/org/thdl/lex/component/RelatedTerm.java new file mode 100644 index 0000000..3d40efd --- /dev/null +++ b/src/java/org/thdl/lex/component/RelatedTerm.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class RelatedTerm extends BaseRelatedTerm implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/SpeechRegister.java b/src/java/org/thdl/lex/component/SpeechRegister.java new file mode 100644 index 0000000..04f2016 --- /dev/null +++ b/src/java/org/thdl/lex/component/SpeechRegister.java @@ -0,0 +1,16 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + + +/** + * Description of the Class + * + * @author travis + * @created October 5, 2003 + */ +public class SpeechRegister extends BaseSpeechRegister implements Serializable +{ + +} + diff --git a/src/java/org/thdl/lex/component/Spelling.java b/src/java/org/thdl/lex/component/Spelling.java new file mode 100644 index 0000000..d9c23fc --- /dev/null +++ b/src/java/org/thdl/lex/component/Spelling.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class Spelling extends BaseSpelling implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/Subdefinition.java b/src/java/org/thdl/lex/component/Subdefinition.java new file mode 100644 index 0000000..bc8758a --- /dev/null +++ b/src/java/org/thdl/lex/component/Subdefinition.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class Subdefinition extends BaseSubdefinition implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/Term.java b/src/java/org/thdl/lex/component/Term.java new file mode 100644 index 0000000..70d0472 --- /dev/null +++ b/src/java/org/thdl/lex/component/Term.java @@ -0,0 +1,15 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + + +/** + * Description of the Class + * + *@author travis + *@created October 3, 2003 + */ +public class Term extends BaseTerm implements Serializable +{ +} + diff --git a/src/java/org/thdl/lex/component/TransitionalData.java b/src/java/org/thdl/lex/component/TransitionalData.java new file mode 100644 index 0000000..93f4be9 --- /dev/null +++ b/src/java/org/thdl/lex/component/TransitionalData.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class TransitionalData extends BaseTransitionalData implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/Translatable.java b/src/java/org/thdl/lex/component/Translatable.java new file mode 100644 index 0000000..c93326e --- /dev/null +++ b/src/java/org/thdl/lex/component/Translatable.java @@ -0,0 +1,6 @@ +package org.thdl.lex.component; + +public interface Translatable +{ + //public java.util.Enumeration getTranslatableFields(); +} diff --git a/src/java/org/thdl/lex/component/TranslationEquivalent.java b/src/java/org/thdl/lex/component/TranslationEquivalent.java new file mode 100644 index 0000000..464c041 --- /dev/null +++ b/src/java/org/thdl/lex/component/TranslationEquivalent.java @@ -0,0 +1,8 @@ +package org.thdl.lex.component; + +import java.io.Serializable; + +public class TranslationEquivalent extends BaseTranslationEquivalent implements Serializable +{ + +} diff --git a/src/java/org/thdl/lex/component/child/Author.hbm.xml b/src/java/org/thdl/lex/component/child/Author.hbm.xml new file mode 100644 index 0000000..33dd9e1 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Author.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/Author.java b/src/java/org/thdl/lex/component/child/Author.java new file mode 100644 index 0000000..cedd060 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Author.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class Author implements Serializable { + + /** identifier field */ + private java.lang.Integer id; + + /** persistent field */ + private java.lang.String author; + + /** full constructor */ + public Author(java.lang.String author) { + this.author = author; + } + + /** default constructor */ + public Author() { + } + + public java.lang.Integer getId() { + return this.id; + } + + public void setId(java.lang.Integer id) { + this.id = id; + } + + public java.lang.String getAuthor() { + return this.author; + } + + public void setAuthor(java.lang.String author) { + this.author = author; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof Author) ) return false; + Author castOther = (Author) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/Dialect.hbm.xml b/src/java/org/thdl/lex/component/child/Dialect.hbm.xml new file mode 100644 index 0000000..f9348a6 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Dialect.hbm.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/Dialect.java b/src/java/org/thdl/lex/component/child/Dialect.java new file mode 100644 index 0000000..6973adc --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Dialect.java @@ -0,0 +1,74 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class Dialect implements Serializable { + + /** identifier field */ + private java.lang.Integer id; + + /** persistent field */ + private short majorDialectFamily; + + /** persistent field */ + private short specificDialect; + + /** full constructor */ + public Dialect(short majorDialectFamily, short specificDialect) { + this.majorDialectFamily = majorDialectFamily; + this.specificDialect = specificDialect; + } + + /** default constructor */ + public Dialect() { + } + + public java.lang.Integer getId() { + return this.id; + } + + public void setId(java.lang.Integer id) { + this.id = id; + } + + public short getMajorDialectFamily() { + return this.majorDialectFamily; + } + + public void setMajorDialectFamily(short majorDialectFamily) { + this.majorDialectFamily = majorDialectFamily; + } + + public short getSpecificDialect() { + return this.specificDialect; + } + + public void setSpecificDialect(short specificDialect) { + this.specificDialect = specificDialect; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof Dialect) ) return false; + Dialect castOther = (Dialect) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/EtymologyType.hbm.xml b/src/java/org/thdl/lex/component/child/EtymologyType.hbm.xml new file mode 100644 index 0000000..79d4bb7 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/EtymologyType.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/EtymologyType.java b/src/java/org/thdl/lex/component/child/EtymologyType.java new file mode 100644 index 0000000..6cbd036 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/EtymologyType.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class EtymologyType implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private java.lang.String etymologyType; + + /** full constructor */ + public EtymologyType(java.lang.String etymologyType) { + this.etymologyType = etymologyType; + } + + /** default constructor */ + public EtymologyType() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getEtymologyType() { + return this.etymologyType; + } + + public void setEtymologyType(java.lang.String etymologyType) { + this.etymologyType = etymologyType; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof EtymologyType) ) return false; + EtymologyType castOther = (EtymologyType) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/Function.hbm.xml b/src/java/org/thdl/lex/component/child/Function.hbm.xml new file mode 100644 index 0000000..453522e --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Function.hbm.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/Function.java b/src/java/org/thdl/lex/component/child/Function.java new file mode 100644 index 0000000..da2c355 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Function.java @@ -0,0 +1,74 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class Function implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private short functionGeneral; + + /** persistent field */ + private short functionSpecific; + + /** full constructor */ + public Function(short functionGeneral, short functionSpecific) { + this.functionGeneral = functionGeneral; + this.functionSpecific = functionSpecific; + } + + /** default constructor */ + public Function() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public short getFunctionGeneral() { + return this.functionGeneral; + } + + public void setFunctionGeneral(short functionGeneral) { + this.functionGeneral = functionGeneral; + } + + public short getFunctionSpecific() { + return this.functionSpecific; + } + + public void setFunctionSpecific(short functionSpecific) { + this.functionSpecific = functionSpecific; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof Function) ) return false; + Function castOther = (Function) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/FunctionGeneral.java b/src/java/org/thdl/lex/component/child/FunctionGeneral.java new file mode 100644 index 0000000..9afa24c --- /dev/null +++ b/src/java/org/thdl/lex/component/child/FunctionGeneral.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class FunctionGeneral implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private java.lang.String functionGeneral; + + /** full constructor */ + public FunctionGeneral(java.lang.String functionGeneral) { + this.functionGeneral = functionGeneral; + } + + /** default constructor */ + public FunctionGeneral() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getFunctionGeneral() { + return this.functionGeneral; + } + + public void setFunctionGeneral(java.lang.String functionGeneral) { + this.functionGeneral = functionGeneral; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof FunctionGeneral) ) return false; + FunctionGeneral castOther = (FunctionGeneral) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/FunctionPrimitive.java b/src/java/org/thdl/lex/component/child/FunctionPrimitive.java new file mode 100644 index 0000000..514ab07 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/FunctionPrimitive.java @@ -0,0 +1,74 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class FunctionPrimitive implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private short functionGeneral; + + /** persistent field */ + private short functionSpecific; + + /** full constructor */ + public FunctionPrimitive(short functionGeneral, short functionSpecific) { + this.functionGeneral = functionGeneral; + this.functionSpecific = functionSpecific; + } + + /** default constructor */ + public FunctionPrimitive() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public short getFunctionGeneral() { + return this.functionGeneral; + } + + public void setFunctionGeneral(short functionGeneral) { + this.functionGeneral = functionGeneral; + } + + public short getFunctionSpecific() { + return this.functionSpecific; + } + + public void setFunctionSpecific(short functionSpecific) { + this.functionSpecific = functionSpecific; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof FunctionPrimitive) ) return false; + FunctionPrimitive castOther = (FunctionPrimitive) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/FunctionSpecific.java b/src/java/org/thdl/lex/component/child/FunctionSpecific.java new file mode 100644 index 0000000..765b056 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/FunctionSpecific.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class FunctionSpecific implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private java.lang.String functionSpecific; + + /** full constructor */ + public FunctionSpecific(java.lang.String functionSpecific) { + this.functionSpecific = functionSpecific; + } + + /** default constructor */ + public FunctionSpecific() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getFunctionSpecific() { + return this.functionSpecific; + } + + public void setFunctionSpecific(java.lang.String functionSpecific) { + this.functionSpecific = functionSpecific; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof FunctionSpecific) ) return false; + FunctionSpecific castOther = (FunctionSpecific) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/FunctionsGeneral.hbm.xml b/src/java/org/thdl/lex/component/child/FunctionsGeneral.hbm.xml new file mode 100644 index 0000000..51c51ff --- /dev/null +++ b/src/java/org/thdl/lex/component/child/FunctionsGeneral.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/FunctionsGeneral.java b/src/java/org/thdl/lex/component/child/FunctionsGeneral.java new file mode 100644 index 0000000..0b6fe37 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/FunctionsGeneral.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class FunctionsGeneral implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private java.lang.String functionGeneral; + + /** full constructor */ + public FunctionsGeneral(java.lang.String functionGeneral) { + this.functionGeneral = functionGeneral; + } + + /** default constructor */ + public FunctionsGeneral() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getFunctionGeneral() { + return this.functionGeneral; + } + + public void setFunctionGeneral(java.lang.String functionGeneral) { + this.functionGeneral = functionGeneral; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof FunctionsGeneral) ) return false; + FunctionsGeneral castOther = (FunctionsGeneral) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/FunctionsSpecific.hbm.xml b/src/java/org/thdl/lex/component/child/FunctionsSpecific.hbm.xml new file mode 100644 index 0000000..1fb47ad --- /dev/null +++ b/src/java/org/thdl/lex/component/child/FunctionsSpecific.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/FunctionsSpecific.java b/src/java/org/thdl/lex/component/child/FunctionsSpecific.java new file mode 100644 index 0000000..1da5c39 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/FunctionsSpecific.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class FunctionsSpecific implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private java.lang.String functionSpecific; + + /** full constructor */ + public FunctionsSpecific(java.lang.String functionSpecific) { + this.functionSpecific = functionSpecific; + } + + /** default constructor */ + public FunctionsSpecific() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getFunctionSpecific() { + return this.functionSpecific; + } + + public void setFunctionSpecific(java.lang.String functionSpecific) { + this.functionSpecific = functionSpecific; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof FunctionsSpecific) ) return false; + FunctionsSpecific castOther = (FunctionsSpecific) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/Language.hbm.xml b/src/java/org/thdl/lex/component/child/Language.hbm.xml new file mode 100644 index 0000000..ee25d68 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Language.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/Language.java b/src/java/org/thdl/lex/component/child/Language.java new file mode 100644 index 0000000..9928e33 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Language.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class Language implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private java.lang.String language; + + /** full constructor */ + public Language(java.lang.String language) { + this.language = language; + } + + /** default constructor */ + public Language() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getLanguage() { + return this.language; + } + + public void setLanguage(java.lang.String language) { + this.language = language; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof Language) ) return false; + Language castOther = (Language) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/LiteraryForm.hbm.xml b/src/java/org/thdl/lex/component/child/LiteraryForm.hbm.xml new file mode 100644 index 0000000..44b7841 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/LiteraryForm.hbm.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/LiteraryForm.java b/src/java/org/thdl/lex/component/child/LiteraryForm.java new file mode 100644 index 0000000..b6c0290 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/LiteraryForm.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class LiteraryForm implements Serializable { + + /** identifier field */ + private java.lang.Integer id; + + /** persistent field */ + private java.lang.String literaryForm; + + /** full constructor */ + public LiteraryForm(java.lang.String literaryForm) { + this.literaryForm = literaryForm; + } + + /** default constructor */ + public LiteraryForm() { + } + + public java.lang.Integer getId() { + return this.id; + } + + public void setId(java.lang.Integer id) { + this.id = id; + } + + public java.lang.String getLiteraryForm() { + return this.literaryForm; + } + + public void setLiteraryForm(java.lang.String literaryForm) { + this.literaryForm = literaryForm; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof LiteraryForm) ) return false; + LiteraryForm castOther = (LiteraryForm) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/LiteraryGenre.hbm.xml b/src/java/org/thdl/lex/component/child/LiteraryGenre.hbm.xml new file mode 100644 index 0000000..03bbe6c --- /dev/null +++ b/src/java/org/thdl/lex/component/child/LiteraryGenre.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/LiteraryGenre.java b/src/java/org/thdl/lex/component/child/LiteraryGenre.java new file mode 100644 index 0000000..03ddc2f --- /dev/null +++ b/src/java/org/thdl/lex/component/child/LiteraryGenre.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class LiteraryGenre implements Serializable { + + /** identifier field */ + private java.lang.Integer id; + + /** persistent field */ + private java.lang.String literaryGenre; + + /** full constructor */ + public LiteraryGenre(java.lang.String literaryGenre) { + this.literaryGenre = literaryGenre; + } + + /** default constructor */ + public LiteraryGenre() { + } + + public java.lang.Integer getId() { + return this.id; + } + + public void setId(java.lang.Integer id) { + this.id = id; + } + + public java.lang.String getLiteraryGenre() { + return this.literaryGenre; + } + + public void setLiteraryGenre(java.lang.String literaryGenre) { + this.literaryGenre = literaryGenre; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof LiteraryGenre) ) return false; + LiteraryGenre castOther = (LiteraryGenre) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/LiteraryPeriod.hbm.xml b/src/java/org/thdl/lex/component/child/LiteraryPeriod.hbm.xml new file mode 100644 index 0000000..e20c009 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/LiteraryPeriod.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/LiteraryPeriod.java b/src/java/org/thdl/lex/component/child/LiteraryPeriod.java new file mode 100644 index 0000000..8da7ae3 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/LiteraryPeriod.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class LiteraryPeriod implements Serializable { + + /** identifier field */ + private java.lang.Integer id; + + /** persistent field */ + private java.lang.String literaryPeriod; + + /** full constructor */ + public LiteraryPeriod(java.lang.String literaryPeriod) { + this.literaryPeriod = literaryPeriod; + } + + /** default constructor */ + public LiteraryPeriod() { + } + + public java.lang.Integer getId() { + return this.id; + } + + public void setId(java.lang.Integer id) { + this.id = id; + } + + public java.lang.String getLiteraryPeriod() { + return this.literaryPeriod; + } + + public void setLiteraryPeriod(java.lang.String literaryPeriod) { + this.literaryPeriod = literaryPeriod; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof LiteraryPeriod) ) return false; + LiteraryPeriod castOther = (LiteraryPeriod) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/LiterarySource.hbm.xml b/src/java/org/thdl/lex/component/child/LiterarySource.hbm.xml new file mode 100644 index 0000000..a133000 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/LiterarySource.hbm.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/LiterarySource.java b/src/java/org/thdl/lex/component/child/LiterarySource.java new file mode 100644 index 0000000..925950b --- /dev/null +++ b/src/java/org/thdl/lex/component/child/LiterarySource.java @@ -0,0 +1,211 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class LiterarySource implements Serializable { + + /** identifier field */ + private java.lang.Integer id; + + /** nullable persistent field */ + private java.lang.Integer literaryPeriod; + + /** nullable persistent field */ + private java.lang.Integer literaryGenre; + + /** nullable persistent field */ + private java.lang.Integer literaryForm; + + /** nullable persistent field */ + private java.lang.Integer author; + + /** nullable persistent field */ + private java.lang.String sourceNormalizedTitle; + + /** nullable persistent field */ + private java.lang.String tibetanDate; + + /** nullable persistent field */ + private java.lang.String internationalDate; + + /** nullable persistent field */ + private java.lang.String edition; + + /** nullable persistent field */ + private java.lang.String publisher; + + /** nullable persistent field */ + private java.lang.String isbn; + + /** nullable persistent field */ + private java.util.Date yearPublished; + + /** persistent field */ + private java.lang.Integer volumeNumber; + + /** nullable persistent field */ + private java.lang.String pagination; + + /** full constructor */ + public LiterarySource(java.lang.Integer literaryPeriod, java.lang.Integer literaryGenre, java.lang.Integer literaryForm, java.lang.Integer author, java.lang.String sourceNormalizedTitle, java.lang.String tibetanDate, java.lang.String internationalDate, java.lang.String edition, java.lang.String publisher, java.lang.String isbn, java.util.Date yearPublished, java.lang.Integer volumeNumber, java.lang.String pagination) { + this.literaryPeriod = literaryPeriod; + this.literaryGenre = literaryGenre; + this.literaryForm = literaryForm; + this.author = author; + this.sourceNormalizedTitle = sourceNormalizedTitle; + this.tibetanDate = tibetanDate; + this.internationalDate = internationalDate; + this.edition = edition; + this.publisher = publisher; + this.isbn = isbn; + this.yearPublished = yearPublished; + this.volumeNumber = volumeNumber; + this.pagination = pagination; + } + + /** default constructor */ + public LiterarySource() { + } + + /** minimal constructor */ + public LiterarySource(java.lang.Integer volumeNumber) { + this.volumeNumber = volumeNumber; + } + + public java.lang.Integer getId() { + return this.id; + } + + public void setId(java.lang.Integer id) { + this.id = id; + } + + public java.lang.Integer getLiteraryPeriod() { + return this.literaryPeriod; + } + + public void setLiteraryPeriod(java.lang.Integer literaryPeriod) { + this.literaryPeriod = literaryPeriod; + } + + public java.lang.Integer getLiteraryGenre() { + return this.literaryGenre; + } + + public void setLiteraryGenre(java.lang.Integer literaryGenre) { + this.literaryGenre = literaryGenre; + } + + public java.lang.Integer getLiteraryForm() { + return this.literaryForm; + } + + public void setLiteraryForm(java.lang.Integer literaryForm) { + this.literaryForm = literaryForm; + } + + public java.lang.Integer getAuthor() { + return this.author; + } + + public void setAuthor(java.lang.Integer author) { + this.author = author; + } + + public java.lang.String getSourceNormalizedTitle() { + return this.sourceNormalizedTitle; + } + + public void setSourceNormalizedTitle(java.lang.String sourceNormalizedTitle) { + this.sourceNormalizedTitle = sourceNormalizedTitle; + } + + public java.lang.String getTibetanDate() { + return this.tibetanDate; + } + + public void setTibetanDate(java.lang.String tibetanDate) { + this.tibetanDate = tibetanDate; + } + + public java.lang.String getInternationalDate() { + return this.internationalDate; + } + + public void setInternationalDate(java.lang.String internationalDate) { + this.internationalDate = internationalDate; + } + + public java.lang.String getEdition() { + return this.edition; + } + + public void setEdition(java.lang.String edition) { + this.edition = edition; + } + + public java.lang.String getPublisher() { + return this.publisher; + } + + public void setPublisher(java.lang.String publisher) { + this.publisher = publisher; + } + + public java.lang.String getIsbn() { + return this.isbn; + } + + public void setIsbn(java.lang.String isbn) { + this.isbn = isbn; + } + + public java.util.Date getYearPublished() { + return this.yearPublished; + } + + public void setYearPublished(java.util.Date yearPublished) { + this.yearPublished = yearPublished; + } + + public java.lang.Integer getVolumeNumber() { + return this.volumeNumber; + } + + public void setVolumeNumber(java.lang.Integer volumeNumber) { + this.volumeNumber = volumeNumber; + } + + public java.lang.String getPagination() { + return this.pagination; + } + + public void setPagination(java.lang.String pagination) { + this.pagination = pagination; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof LiterarySource) ) return false; + LiterarySource castOther = (LiterarySource) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/MajorDialectFamily.hbm.xml b/src/java/org/thdl/lex/component/child/MajorDialectFamily.hbm.xml new file mode 100644 index 0000000..af3e28f --- /dev/null +++ b/src/java/org/thdl/lex/component/child/MajorDialectFamily.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/MajorDialectFamily.java b/src/java/org/thdl/lex/component/child/MajorDialectFamily.java new file mode 100644 index 0000000..9865d81 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/MajorDialectFamily.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class MajorDialectFamily implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** nullable persistent field */ + private java.lang.String majorDialectFamily; + + /** full constructor */ + public MajorDialectFamily(java.lang.String majorDialectFamily) { + this.majorDialectFamily = majorDialectFamily; + } + + /** default constructor */ + public MajorDialectFamily() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getMajorDialectFamily() { + return this.majorDialectFamily; + } + + public void setMajorDialectFamily(java.lang.String majorDialectFamily) { + this.majorDialectFamily = majorDialectFamily; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof MajorDialectFamily) ) return false; + MajorDialectFamily castOther = (MajorDialectFamily) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/PhoneticsType.hbm.xml b/src/java/org/thdl/lex/component/child/PhoneticsType.hbm.xml new file mode 100644 index 0000000..9d78f8d --- /dev/null +++ b/src/java/org/thdl/lex/component/child/PhoneticsType.hbm.xml @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/PhoneticsType.java b/src/java/org/thdl/lex/component/child/PhoneticsType.java new file mode 100644 index 0000000..f3640a6 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/PhoneticsType.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class PhoneticsType implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private java.lang.String phoneticsType; + + /** full constructor */ + public PhoneticsType(java.lang.String phoneticsType) { + this.phoneticsType = phoneticsType; + } + + /** default constructor */ + public PhoneticsType() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getPhoneticsType() { + return this.phoneticsType; + } + + public void setPhoneticsType(java.lang.String phoneticsType) { + this.phoneticsType = phoneticsType; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof PhoneticsType) ) return false; + PhoneticsType castOther = (PhoneticsType) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/Preferences.hbm.xml b/src/java/org/thdl/lex/component/child/Preferences.hbm.xml new file mode 100644 index 0000000..24c6129 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Preferences.hbm.xml @@ -0,0 +1,37 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/ProjectSubject.hbm.xml b/src/java/org/thdl/lex/component/child/ProjectSubject.hbm.xml new file mode 100644 index 0000000..4b23e11 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/ProjectSubject.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/ProjectSubject.java b/src/java/org/thdl/lex/component/child/ProjectSubject.java new file mode 100644 index 0000000..e8a8802 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/ProjectSubject.java @@ -0,0 +1,91 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class ProjectSubject implements Serializable { + + /** identifier field */ + private java.lang.Integer id; + + /** nullable persistent field */ + private java.lang.String projectSubject; + + /** persistent field */ + private java.lang.Integer leader; + + /** nullable persistent field */ + private java.lang.String participantList; + + /** full constructor */ + public ProjectSubject(java.lang.String projectSubject, java.lang.Integer leader, java.lang.String participantList) { + this.projectSubject = projectSubject; + this.leader = leader; + this.participantList = participantList; + } + + /** default constructor */ + public ProjectSubject() { + } + + /** minimal constructor */ + public ProjectSubject(java.lang.Integer leader) { + this.leader = leader; + } + + public java.lang.Integer getId() { + return this.id; + } + + public void setId(java.lang.Integer id) { + this.id = id; + } + + public java.lang.String getProjectSubject() { + return this.projectSubject; + } + + public void setProjectSubject(java.lang.String projectSubject) { + this.projectSubject = projectSubject; + } + + public java.lang.Integer getLeader() { + return this.leader; + } + + public void setLeader(java.lang.Integer leader) { + this.leader = leader; + } + + public java.lang.String getParticipantList() { + return this.participantList; + } + + public void setParticipantList(java.lang.String participantList) { + this.participantList = participantList; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof ProjectSubject) ) return false; + ProjectSubject castOther = (ProjectSubject) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/Register.hbm.xml b/src/java/org/thdl/lex/component/child/Register.hbm.xml new file mode 100644 index 0000000..af64d80 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Register.hbm.xml @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/Register.java b/src/java/org/thdl/lex/component/child/Register.java new file mode 100644 index 0000000..7396683 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Register.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class Register implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private java.lang.String register; + + /** full constructor */ + public Register(java.lang.String register) { + this.register = register; + } + + /** default constructor */ + public Register() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getRegister() { + return this.register; + } + + public void setRegister(java.lang.String register) { + this.register = register; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof Register) ) return false; + Register castOther = (Register) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/RelatedTermType.hbm.xml b/src/java/org/thdl/lex/component/child/RelatedTermType.hbm.xml new file mode 100644 index 0000000..84a6ba8 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/RelatedTermType.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/RelatedTermType.java b/src/java/org/thdl/lex/component/child/RelatedTermType.java new file mode 100644 index 0000000..fb5d73e --- /dev/null +++ b/src/java/org/thdl/lex/component/child/RelatedTermType.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class RelatedTermType implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private java.lang.String relatedTermType; + + /** full constructor */ + public RelatedTermType(java.lang.String relatedTermType) { + this.relatedTermType = relatedTermType; + } + + /** default constructor */ + public RelatedTermType() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getRelatedTermType() { + return this.relatedTermType; + } + + public void setRelatedTermType(java.lang.String relatedTermType) { + this.relatedTermType = relatedTermType; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof RelatedTermType) ) return false; + RelatedTermType castOther = (RelatedTermType) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/Script.hbm.xml b/src/java/org/thdl/lex/component/child/Script.hbm.xml new file mode 100644 index 0000000..7c733bf --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Script.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/Script.java b/src/java/org/thdl/lex/component/child/Script.java new file mode 100644 index 0000000..981990b --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Script.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class Script implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private java.lang.String script; + + /** full constructor */ + public Script(java.lang.String script) { + this.script = script; + } + + /** default constructor */ + public Script() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getScript() { + return this.script; + } + + public void setScript(java.lang.String script) { + this.script = script; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof Script) ) return false; + Script castOther = (Script) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/Source.hbm.xml b/src/java/org/thdl/lex/component/child/Source.hbm.xml new file mode 100644 index 0000000..e5dee6b --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Source.hbm.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/Source.java b/src/java/org/thdl/lex/component/child/Source.java new file mode 100644 index 0000000..ee9f752 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/Source.java @@ -0,0 +1,79 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class Source implements Serializable { + + /** identifier field */ + private java.lang.Integer id; + + /** persistent field */ + private java.lang.String sourceTitle; + + /** nullable persistent field */ + private java.lang.String sourceDescription; + + /** full constructor */ + public Source(java.lang.String sourceTitle, java.lang.String sourceDescription) { + this.sourceTitle = sourceTitle; + this.sourceDescription = sourceDescription; + } + + /** default constructor */ + public Source() { + } + + /** minimal constructor */ + public Source(java.lang.String sourceTitle) { + this.sourceTitle = sourceTitle; + } + + public java.lang.Integer getId() { + return this.id; + } + + public void setId(java.lang.Integer id) { + this.id = id; + } + + public java.lang.String getSourceTitle() { + return this.sourceTitle; + } + + public void setSourceTitle(java.lang.String sourceTitle) { + this.sourceTitle = sourceTitle; + } + + public java.lang.String getSourceDescription() { + return this.sourceDescription; + } + + public void setSourceDescription(java.lang.String sourceDescription) { + this.sourceDescription = sourceDescription; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof Source) ) return false; + Source castOther = (Source) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/SpecificDialect.hbm.xml b/src/java/org/thdl/lex/component/child/SpecificDialect.hbm.xml new file mode 100644 index 0000000..e2c2bf2 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/SpecificDialect.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/SpecificDialect.java b/src/java/org/thdl/lex/component/child/SpecificDialect.java new file mode 100644 index 0000000..bbccfaa --- /dev/null +++ b/src/java/org/thdl/lex/component/child/SpecificDialect.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class SpecificDialect implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** nullable persistent field */ + private java.lang.String specificDialect; + + /** full constructor */ + public SpecificDialect(java.lang.String specificDialect) { + this.specificDialect = specificDialect; + } + + /** default constructor */ + public SpecificDialect() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getSpecificDialect() { + return this.specificDialect; + } + + public void setSpecificDialect(java.lang.String specificDialect) { + this.specificDialect = specificDialect; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof SpecificDialect) ) return false; + SpecificDialect castOther = (SpecificDialect) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/SpellingType.hbm.xml b/src/java/org/thdl/lex/component/child/SpellingType.hbm.xml new file mode 100644 index 0000000..9d9727e --- /dev/null +++ b/src/java/org/thdl/lex/component/child/SpellingType.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/SpellingType.java b/src/java/org/thdl/lex/component/child/SpellingType.java new file mode 100644 index 0000000..0e1c628 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/SpellingType.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class SpellingType implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** persistent field */ + private java.lang.String spellingType; + + /** full constructor */ + public SpellingType(java.lang.String spellingType) { + this.spellingType = spellingType; + } + + /** default constructor */ + public SpellingType() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getSpellingType() { + return this.spellingType; + } + + public void setSpellingType(java.lang.String spellingType) { + this.spellingType = spellingType; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof SpellingType) ) return false; + SpellingType castOther = (SpellingType) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/TransitionalDataLabel.hbm.xml b/src/java/org/thdl/lex/component/child/TransitionalDataLabel.hbm.xml new file mode 100644 index 0000000..70df7fa --- /dev/null +++ b/src/java/org/thdl/lex/component/child/TransitionalDataLabel.hbm.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + diff --git a/src/java/org/thdl/lex/component/child/TransitionalDataLabel.java b/src/java/org/thdl/lex/component/child/TransitionalDataLabel.java new file mode 100644 index 0000000..08c832d --- /dev/null +++ b/src/java/org/thdl/lex/component/child/TransitionalDataLabel.java @@ -0,0 +1,62 @@ +package org.thdl.lex.component.child; + +import java.io.Serializable; +import org.apache.commons.lang.builder.EqualsBuilder; +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.commons.lang.builder.ToStringBuilder; + +/** @author Hibernate CodeGenerator */ +public class TransitionalDataLabel implements Serializable { + + /** identifier field */ + private java.lang.Short id; + + /** nullable persistent field */ + private java.lang.String transitionalDataLabel; + + /** full constructor */ + public TransitionalDataLabel(java.lang.String transitionalDataLabel) { + this.transitionalDataLabel = transitionalDataLabel; + } + + /** default constructor */ + public TransitionalDataLabel() { + } + + public java.lang.Short getId() { + return this.id; + } + + public void setId(java.lang.Short id) { + this.id = id; + } + + public java.lang.String getTransitionalDataLabel() { + return this.transitionalDataLabel; + } + + public void setTransitionalDataLabel(java.lang.String transitionalDataLabel) { + this.transitionalDataLabel = transitionalDataLabel; + } + + public String toString() { + return new ToStringBuilder(this) + .append("id", getId()) + .toString(); + } + + public boolean equals(Object other) { + if ( !(other instanceof TransitionalDataLabel) ) return false; + TransitionalDataLabel castOther = (TransitionalDataLabel) other; + return new EqualsBuilder() + .append(this.getId(), castOther.getId()) + .isEquals(); + } + + public int hashCode() { + return new HashCodeBuilder() + .append(getId()) + .toHashCode(); + } + +} diff --git a/src/java/org/thdl/lex/component/child/User.hbm.xml b/src/java/org/thdl/lex/component/child/User.hbm.xml new file mode 100644 index 0000000..6847f73 --- /dev/null +++ b/src/java/org/thdl/lex/component/child/User.hbm.xml @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/jsp/index.jsp b/src/jsp/index.jsp new file mode 100644 index 0000000..b131577 --- /dev/null +++ b/src/jsp/index.jsp @@ -0,0 +1,24 @@ +<%@ page buffer="12kb" autoFlush="true" import="org.thdl.lex.*" errorPage="/jsp/error.jsp" %> + + +
THDL Tibetan Dictionary Home Page
+
Last Updated: January 23, 2003
+
+

+Search Dictionary +

+

+Spotlight
+At present there is only one word — thod rgal. +Over the coming weeks David Germano will be entering further Buddhist terminology, +and opening up the Encyclopedia portion with extended descriptions. +Other projects on the horizon: +Frances Garrett's Medical Terminology glossary and Materia Medica database, +Matthew Kapstein's Classical Literary terminology glossary, +Nicolas Tournade's Colloquial Lhasan terminology glossary. +Last updated: January 22, 2003. +

+
+ + + diff --git a/src/jsp/jsp/analyticalNoteForm.jsf b/src/jsp/jsp/analyticalNoteForm.jsf new file mode 100644 index 0000000..e4df404 --- /dev/null +++ b/src/jsp/jsp/analyticalNoteForm.jsf @@ -0,0 +1,46 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + + + + + + + + + + + + + + + + + + + + +
+

+ + + + + + + + +Analysis:
+ +
+ + + + +

+
diff --git a/src/jsp/jsp/debug.jsf b/src/jsp/jsp/debug.jsf new file mode 100644 index 0000000..c95f003 --- /dev/null +++ b/src/jsp/jsp/debug.jsf @@ -0,0 +1,70 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" errorPage="/jsp/error.jsp" %> +<%@ taglib prefix = "c" uri = "http://java.sun.com/jstl/core" %> +<%@ taglib prefix = "req" uri = "http://jakarta.apache.org/taglibs/request-1.0" %> +<%@ taglib prefix = "res" uri = "http://jakarta.apache.org/taglibs/response-1.0" %> +<%@ taglib prefix = "sess" uri = "http://jakarta.apache.org/taglibs/session-1.0" %> +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
+

DEBUG INFO

+ +Validate CSS + +
+

+Request Parameters:

+ + = ''
+ +
+

+ Request Attributes:

+ + = ''
+ + +
+

+ Session Attributes:

+ + = ''
+ +
+ +

+ Response Headers:

+ +
+ +

Results Array Items:

+ +
+ + +
+
diff --git a/src/jsp/jsp/definitionForm.jsf b/src/jsp/jsp/definitionForm.jsf new file mode 100644 index 0000000..a6a3a98 --- /dev/null +++ b/src/jsp/jsp/definitionForm.jsf @@ -0,0 +1,63 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+

+ + + + + + + + + + + + + +Definition:
+ + +
+ +Precedence:
+ + + + +

+
diff --git a/src/jsp/jsp/displayEntry.jsp b/src/jsp/jsp/displayEntry.jsp new file mode 100644 index 0000000..371b1df --- /dev/null +++ b/src/jsp/jsp/displayEntry.jsp @@ -0,0 +1,86 @@ +<%-- <%@ page buffer="512kb" autoFlush="false" import="org.thdl.lex.*,org.thdl.lex.component.*" errorPage="/jsp/error.jsp" %>--%> +<%@ page buffer="512kb" autoFlush="false" import="org.thdl.lex.*,org.thdl.lex.component.*" errorPage="/jsp/error.jsp" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + + + + +

Search Results Page

+
+

+ + + .
+ + + <%-- --%> + + +

+
+ +
+ + + +<%-- --%> + + + + + + + + + + + +<%-- --%> +
+ + + + diff --git a/src/jsp/jsp/displayForm.jsp b/src/jsp/jsp/displayForm.jsp new file mode 100644 index 0000000..b62ef77 --- /dev/null +++ b/src/jsp/jsp/displayForm.jsp @@ -0,0 +1,114 @@ +<%-- <%@ page buffer="512kb" autoFlush="false" import="org.thdl.lex.*,org.thdl.lex.component.*" errorPage="/jsp/error.jsp" %>--%> +<%@ page buffer="512kb" autoFlush="false" import="org.thdl.lex.*,org.thdl.lex.component.*" errorPage="/jsp/error.jsp" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + +
Component Entry Form Page +
+ +
+ + + +
+ +
+ +
+Back to: + +
+ + + + + + + + + + + + + + + + + + + +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Error: no form was included + + + +
+ + + + diff --git a/src/jsp/jsp/displayMeta.jsf b/src/jsp/jsp/displayMeta.jsf new file mode 100644 index 0000000..056b961 --- /dev/null +++ b/src/jsp/jsp/displayMeta.jsf @@ -0,0 +1,36 @@ +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + Id: +
+ +Created by + +on +for +
+Modified by +on +for +
+Source: +
+Script: +
+Language: +
+Dialect: +
+Translation: + + +Yes (of ) + + +No + + +
+Note:
+ + diff --git a/src/jsp/jsp/displayTree.jsf b/src/jsp/jsp/displayTree.jsf new file mode 100644 index 0000000..11ef170 --- /dev/null +++ b/src/jsp/jsp/displayTree.jsf @@ -0,0 +1,628 @@ +<%-- + --%> +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" buffer="512kb" autoFlush="false"%> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + +<%-- This whole edit/update/display should be REWRITTEN! --%> + + + + + + + + + + + + + + + +

+ + + + +
+
+

+ + + + + + +

+ + + +

+ + + + + + + + + + + + + + + + + + + + + + + Term:
+ <%-- metadata + + + --%> + + + analysis + Analysis:
+ + + + +

+ + + +
+ + + + + + +

+ + + + + + + + + + +
+
+ view metadata + + + + + + analysis + Analysis:
+ + + + +

+ + + + +

+ + + + + + + + + + + Phonetic Rendering:
+ Type of Phonetics:
+ view metadata + + + + + + analysis + Analysis:
+ + + + +

+ + + + +

+ + + + + + + + + + + + + Etymology:
+ Etymology Type:
+ Loan Language:
+ Derivation:
+ view metadata + + + + + + + + + + view/edit translation + + Etymology:
+ Etymology Type:
+ Loan Language:
+ Derivation:
+ + + + + + + analysis + Analysis:
+ + + + +

+ + + + + +

+ + + + + + + + + + + Spelling:
+ Spelling Type:
+ view metadata + + + + + + analysis + Analysis:
+ + + + +

+ + + + + +

+ + + + + + + + + + Grammatical Function:
+ view metadata + + + + + + analysis + Analysis:
+ + + + +

+ + + + +

+ + + + + + + + + + + + <%-- Encyclopedia Article:
--%> + Encyclopedia Article:
+ view metadata + + + + + + analysis + Analysis:
+ + + + +

+ + +
+ + + +

+ + + + + + + + + + + + + + + Definition +
+ view metadata + + + + + + + + + + view/edit translation + Definition +
+ + + + + + + analysis + Analysis:
+ + + + +

+ +
+ + + +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + Subdefinition: +
+ view metadata + + + + + + + + + + view/edit translation + Subdefinition: +
+ + + + + + + analysis + Analysis:
+ + + + + +

+ +
+ + + +

+ + + + + + + + + + + Keyword: +
view metadata + + + + + + analysis + Analysis:
+ + + + +

+ + + + + +

+ + + + + + + + + + + + + Model Sentence: +
+ view metadata + + + + + + + + + + view/edit translation + Model Sentence:
+ + + + + + + analysis + Analysis:
+ + + + +

+ + + + + + + +

+ + + + + + + + + + + Translation Equivalent: +
+ view metadata + + + + + + analysis + Analysis:
+ + + + +

+ + + + +

+ + + + + + + + + + + Related Term:
+ Related Term Type: +
+ view metadata + + + + + + analysis + Analysis:
+ + + + +

+ + + + +

+ + + + + + + + + + + + + Literary Source:
+ Spelling:
+ Pagination:
+ Passage:
+ view metadata + + + + + + + + + + view/edit translation + Literary Source:
+ Spelling:
+ Pagination:
+ Passage:
+ + + + + + + analysis + Analysis:
+ + + + +

+ + + + +

+ + + + + + + + + + Speech Register: +
+ view metadata + + + + + + analysis + Analysis:
+ + + + +

+ +
+ +
+ + +

 

+

 

+

 

+

 

+ + + +
+ + + + diff --git a/src/jsp/jsp/encyclopedia.jsf b/src/jsp/jsp/encyclopedia.jsf new file mode 100644 index 0000000..7d68b8b --- /dev/null +++ b/src/jsp/jsp/encyclopedia.jsf @@ -0,0 +1,19 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" buffer="512kb" autoFlush="false"%> +<%-- <%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" errorPage="/jsp/error.jsp" buffer="512kb" autoFlush="false" %> --%> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + +

Encyclopedia Article

+

+ Title:
+

+

+ Author: + +

+

+ Article:
+
+

diff --git a/src/jsp/jsp/encyclopediaArticleForm.jsf b/src/jsp/jsp/encyclopediaArticleForm.jsf new file mode 100644 index 0000000..2f30347 --- /dev/null +++ b/src/jsp/jsp/encyclopediaArticleForm.jsf @@ -0,0 +1,55 @@ +<%-- <%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" errorPage="/jsp/error.jsp" %> --%> +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %><%@ page import="java.util.HashMap" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> +<%-- <%@ taglib prefix="input" uri="http://jakarta.apache.org/taglibs/input-1.0" %> --%> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+

+ + + + + + + +Article Title:
+ +
+ +Article:
+ +
+ + + + +

+
diff --git a/src/jsp/jsp/error.jsp b/src/jsp/jsp/error.jsp new file mode 100644 index 0000000..f2684b5 --- /dev/null +++ b/src/jsp/jsp/error.jsp @@ -0,0 +1,67 @@ +<%@ page import="java.io.PrintWriter,java.io.StringWriter,org.thdl.lex.*,org.thdl.lex.component.*" isErrorPage="true" %> +<%@ taglib prefix="req" uri="http://jakarta.apache.org/taglibs/request-1.0" %> + + + + + + + +THDL Dictionary Error Page + + + +
+

+You have reached the Error page. +This page indicates that Lex has caught an exception that it does not know how to deal with. +The message appears below.
+Return to the home page.

+ + +Message: <%= exception.getMessage() %>

+ +<% if (request.getAttribute("component") != null) + { LexComponent lab = (LexComponent) request.getAttribute("component"); +%> + Label: <%= lab %>

+<%-- Sql String: <%= lab.getSqlString() %> + --%> + +<% } %>

+ +Stack Trace: +<% StringWriter writer = new StringWriter(); + exception.printStackTrace( new PrintWriter(writer) ); + String stackTrace = writer.getBuffer().toString(); +%> +

+<%= stackTrace %>
+
+

+
+ + + + + diff --git a/src/jsp/jsp/etymologyForm.jsf b/src/jsp/jsp/etymologyForm.jsf new file mode 100644 index 0000000..c7b1480 --- /dev/null +++ b/src/jsp/jsp/etymologyForm.jsf @@ -0,0 +1,116 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> +<%-- <%@ taglib prefix="input" uri="http://jakarta.apache.org/taglibs/input-1.0" %> --%> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+

+ + + + + + + + + + + + + +Etymology Description:
+ +
+ +Etymology Type: + +
+Loan Language: + +
+Derivation: + + + + + +

+
diff --git a/src/jsp/jsp/footer.jsf b/src/jsp/jsp/footer.jsf new file mode 100644 index 0000000..f34ed64 --- /dev/null +++ b/src/jsp/jsp/footer.jsf @@ -0,0 +1,27 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> +<%@ taglib prefix = "req" uri = "http://jakarta.apache.org/taglibs/request-1.0" %> + + + + + + + + + + + + + + + + diff --git a/src/jsp/jsp/functionForm.jsf b/src/jsp/jsp/functionForm.jsf new file mode 100644 index 0000000..66cebdb --- /dev/null +++ b/src/jsp/jsp/functionForm.jsf @@ -0,0 +1,56 @@ +<%-- <%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" errorPage="/jsp/error.jsp" %> --%> +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %><%@ page import="java.util.HashMap" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> +<%-- <%@ taglib prefix="input" uri="http://jakarta.apache.org/taglibs/input-1.0" %> --%> + + + + + + + + + + + + + + + + + + + + + + + + + + +
+

+ + + + + + + +Grammatical Function: + + +
+ + + +

+
diff --git a/src/jsp/jsp/goodbye.jsp b/src/jsp/jsp/goodbye.jsp new file mode 100644 index 0000000..1ce95b1 --- /dev/null +++ b/src/jsp/jsp/goodbye.jsp @@ -0,0 +1,8 @@ + + +

Thank you

+

Click here to log back in.

+ + + + diff --git a/src/jsp/jsp/header.jsf b/src/jsp/jsp/header.jsf new file mode 100644 index 0000000..a98ffb6 --- /dev/null +++ b/src/jsp/jsp/header.jsf @@ -0,0 +1,82 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> +<%-- --%> + + + + +<%-- --%> + + + + + + + + + + +THDL Tibetan Collaborative Dictionaries + + + + + +
+ + + +
+ +
+ + + diff --git a/src/jsp/jsp/keywordForm.jsf b/src/jsp/jsp/keywordForm.jsf new file mode 100644 index 0000000..ecc2b0c --- /dev/null +++ b/src/jsp/jsp/keywordForm.jsf @@ -0,0 +1,45 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + + + + + + + + + + + + + + + + + + + + +
+

+ + + + + + + +Keyword:
+ +
+ + + + +

+
diff --git a/src/jsp/jsp/menu.jsp b/src/jsp/jsp/menu.jsp new file mode 100644 index 0000000..0cf0900 --- /dev/null +++ b/src/jsp/jsp/menu.jsp @@ -0,0 +1,52 @@ +<%@ page buffer="512kb" autoFlush="false" import="org.thdl.lex.*,org.thdl.lex.component.*" errorPage="/jsp/error.jsp" %> + +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + +

THDL Dictionary Server: Main Menu

+ +
+

+Message: + + + +

+
+ +
+ + +

This THDL Dictionary Server is a new online rich dictionary.

+

During development, please follow this advice: +

    +
  • bookmark this page and use the bookmark to get back after any unexpected errors.
    • +
  • Don't refresh pages pages with your browser's refresh commands. After database inserts, a browser refresh will cause a duplicate insert.
    • +
  • After you request to add/edit a component look for the 'GO TO FORM' link in the navigation bar to quickly get to the form.
    • +
+

+
+ + + diff --git a/src/jsp/jsp/metaDefaultsForm.jsp b/src/jsp/jsp/metaDefaultsForm.jsp new file mode 100644 index 0000000..4aa0599 --- /dev/null +++ b/src/jsp/jsp/metaDefaultsForm.jsp @@ -0,0 +1,256 @@ +<%@ page buffer="512kb" autoFlush="false" import="org.thdl.lex.*,org.thdl.lex.component.*" errorPage="/jsp/error.jsp" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + +

Lex the Dictionary Server: Manage Input Session Form

+ +
+

+Message: + + + +

+
+ +
+
+ + + + + + + + +<%--
+
+
+
+ --%> + +

+In the metadata categories below, indicate the option you would like to appear by default. +Then check the "Use Default" box next to metadata fields you want to be entered automatically. +When this box is checked, the dropdown for that field will not appear +(this only applies to forms for new components, not edit forms). +

+ +

+ + + + + +Use Default Language:
+ +

+ +

+ + + + + +Use Default Script:
+ + +

+ +

+ + + + + +Use Default Dialect:
+ +

+ +

+ + + + + +Use Default Source:
+ +

+ +

+ + + + + +Use Default Project/Subject:
+ +

+ +

+ + + + + + +Use Default Metadata Note:
+
+ + + + +

+ + +
+ + + diff --git a/src/jsp/jsp/metaForm.jsf b/src/jsp/jsp/metaForm.jsf new file mode 100644 index 0000000..ba9a48b --- /dev/null +++ b/src/jsp/jsp/metaForm.jsf @@ -0,0 +1,280 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> +<%@ taglib prefix="sess" uri="http://java.sun.com/jstl/core" %> +<%@ taglib prefix="str" uri="http://jakarta.apache.org/taglibs/string-1.0" %> + + + + + + + + + + + <%-- --%> + + + + + + + + + + <%-- --%> + + + + + + + + + + <%-- --%> + + + + + + + + + + + + + + +

+Analysis:
+ +

+ + + + + + + +

+Language: + +

+ + + + + + + + +

+Script: + + +

+ + + + + + + + +<%-- --%> +

+Dialect: + +

+ + + + + + + + +

+Source: + +

+ + + + + + + + +

+Project/Subject: + +

+ + + + + + + + + +

+ +Metadata Note:
+
+

+ + + + + + + diff --git a/src/jsp/jsp/metaPrefsForm.jsp b/src/jsp/jsp/metaPrefsForm.jsp new file mode 100644 index 0000000..8634170 --- /dev/null +++ b/src/jsp/jsp/metaPrefsForm.jsp @@ -0,0 +1,142 @@ +<%@ page buffer="512kb" autoFlush="false" import="org.thdl.lex.*,org.thdl.lex.component.*" errorPage="/jsp/error.jsp" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + +

Lex the Dictionary Server: Manage Input Session Form

+ +
+

+Message: + + + +

+
+ +
+
+

+In the metadata categories below, please choose sets of options that you use frequently. +Use the ctrl-key (command-key on Mac) to select multiple options. +Your choices from this page will appear at the top of every dropdown menu +in the metadata section of every form in this application. +

+ +

+Languages:
+ +

+

+Dialects:
+ +

+

+Sources:
+ +

+

+ +Project/Subject:
+ +

+

+Scripts:
+ + +

+

+ + +

+
+ +
+ + + diff --git a/src/jsp/jsp/modelSentenceForm.jsf b/src/jsp/jsp/modelSentenceForm.jsf new file mode 100644 index 0000000..e71038d --- /dev/null +++ b/src/jsp/jsp/modelSentenceForm.jsf @@ -0,0 +1,62 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + + + + <%-- --%> + + + + + + + + <%-- --%> + + + + + + + <%-- --%> + + + + + + + + + + +
+

+ + + + + + + + + + + + +Model Sentence:
+ +
+ +<%-- Precedence: --%>
+ + + + +

+
diff --git a/src/jsp/jsp/navLinks.jsf b/src/jsp/jsp/navLinks.jsf new file mode 100644 index 0000000..87cb424 --- /dev/null +++ b/src/jsp/jsp/navLinks.jsf @@ -0,0 +1,5 @@ +Dictionary Home | +Search | +Login | +Logout + diff --git a/src/jsp/jsp/passageForm.jsf b/src/jsp/jsp/passageForm.jsf new file mode 100644 index 0000000..0f36e09 --- /dev/null +++ b/src/jsp/jsp/passageForm.jsf @@ -0,0 +1,75 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+

+ + + + + + + + + + + +LiterarySource:
+ +Spelling:
+ + +Pagination:
+
+ + +Passage:
+
+ + + + +

+
diff --git a/src/jsp/jsp/pronunciationForm.jsf b/src/jsp/jsp/pronunciationForm.jsf new file mode 100644 index 0000000..37e7a30 --- /dev/null +++ b/src/jsp/jsp/pronunciationForm.jsf @@ -0,0 +1,63 @@ +<%-- <%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" errorPage="/jsp/error.jsp" %> --%> +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %><%@ page import="java.util.HashMap" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> +<%-- <%@ taglib prefix="input" uri="http://jakarta.apache.org/taglibs/input-1.0" %> --%> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+

+ + + + + + + +Phonetic Rendering:
+ +
+Type of Phonetics: + +
+ + + +

+
diff --git a/src/jsp/jsp/registerForm.jsf b/src/jsp/jsp/registerForm.jsf new file mode 100644 index 0000000..fbb3b61 --- /dev/null +++ b/src/jsp/jsp/registerForm.jsf @@ -0,0 +1,55 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + + + + <%-- --%> + + + + + + + + <%-- --%> + + + + + + + <%-- --%> + + + + +
+

+ + + + + + + +Register: + +
+ + + +

+
diff --git a/src/jsp/jsp/relatedTermForm.jsf b/src/jsp/jsp/relatedTermForm.jsf new file mode 100644 index 0000000..ec71e80 --- /dev/null +++ b/src/jsp/jsp/relatedTermForm.jsf @@ -0,0 +1,64 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + + + + + <%-- --%> + + + + + + + + + <%-- --%> + + + + + + + + + + + +
+

+ + + + + + + +Related Term:
+ +
+ + +Related Term Type: + +
+<%-- Precedence: --%>
+ + + + +

+
diff --git a/src/jsp/jsp/spellingForm.jsf b/src/jsp/jsp/spellingForm.jsf new file mode 100644 index 0000000..7526fc2 --- /dev/null +++ b/src/jsp/jsp/spellingForm.jsf @@ -0,0 +1,61 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%-- <%@ page import="java.util.HashMap" %> --%> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+

+ + + + + + + +Spelling:
+ +
+ +Spelling Type: + +
+ + + +

+
diff --git a/src/jsp/jsp/subdefinitionForm.jsf b/src/jsp/jsp/subdefinitionForm.jsf new file mode 100644 index 0000000..18674f6 --- /dev/null +++ b/src/jsp/jsp/subdefinitionForm.jsf @@ -0,0 +1,61 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+

+ + + + + + + + + + + + +Subdefinition:
+ +
+ +<%-- Precedence:
+ --%> + + + +

+
diff --git a/src/jsp/jsp/termForm.jsf b/src/jsp/jsp/termForm.jsf new file mode 100644 index 0000000..a7a96c2 --- /dev/null +++ b/src/jsp/jsp/termForm.jsf @@ -0,0 +1,49 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+

+ + + + + + +Term: + +
+Precedence:
+ + + + + +

+
diff --git a/src/jsp/jsp/testing.jsf b/src/jsp/jsp/testing.jsf new file mode 100644 index 0000000..3aeecb9 --- /dev/null +++ b/src/jsp/jsp/testing.jsf @@ -0,0 +1,27 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> +<%@ taglib prefix="c_rt" uri="http://java.sun.com/jstl/core_rt" %> + + +

+You have reached the test page by specifying cmd=testing in your request.
+ + + + + +<%-- <% + TermTest component = (TermTest) request.getAttribute("termTest"); +%> + +Id: <%= component.getId() %>
+Term: <%= component.getTerm() %>
+Analytical Notes Hex: <%= component.getAnalyticalNotes().toString() %>
+ + +Id:
+Term:
+Analytical Notes Hex:
--%> + +

+ diff --git a/src/jsp/jsp/transitionalDataForm.jsf b/src/jsp/jsp/transitionalDataForm.jsf new file mode 100644 index 0000000..e0c8130 --- /dev/null +++ b/src/jsp/jsp/transitionalDataForm.jsf @@ -0,0 +1,55 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> +<%-- <%@ taglib prefix="input" uri="http://jakarta.apache.org/taglibs/input-1.0" %> --%> + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+

+ + + + + + + + + + + + + + Text:
+ +
+ + + + +

+
diff --git a/src/jsp/jsp/translationEquivalentForm.jsf b/src/jsp/jsp/translationEquivalentForm.jsf new file mode 100644 index 0000000..2dcd565 --- /dev/null +++ b/src/jsp/jsp/translationEquivalentForm.jsf @@ -0,0 +1,48 @@ +<%@ page import="org.thdl.lex.*,org.thdl.lex.component.*" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> + + + + + + + + + <%-- --%> + + + + + + + + <%-- --%> + + + + + + + <%-- --%> + + + + +
+

+ + + + + + + +Translation Equivalent:
+ +
+ + + + +

+
diff --git a/src/jsp/login.jsp b/src/jsp/login.jsp new file mode 100644 index 0000000..91d6681 --- /dev/null +++ b/src/jsp/login.jsp @@ -0,0 +1,36 @@ +<%@ page buffer="512kb" autoFlush="false" import="org.thdl.lex.*" errorPage="/jsp/error.jsp" %> +<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core"%> + +
+Please login to use Lex the Dictionary Server +
+
Message
+
+
+ + +

Invalid username/password combination.

+ + + + +
+

+Username: +
+Password: +
+ +

+
+
+

+If you are not a dictionary contributor please proceed here. + +

+
+
+
+ + + diff --git a/src/jsp/logout.jsp b/src/jsp/logout.jsp new file mode 100644 index 0000000..b7d034c --- /dev/null +++ b/src/jsp/logout.jsp @@ -0,0 +1,21 @@ + + +
+
+
+Log out of Lex the Dictionary Server
+ +
+ +

+Log out account +

+ +
+ +
+ +
+
+
+ diff --git a/src/sql/lex-flat-schema.sql b/src/sql/lex-flat-schema.sql new file mode 100644 index 0000000..df53fe9 --- /dev/null +++ b/src/sql/lex-flat-schema.sql @@ -0,0 +1,552 @@ +-- MySQL dump 8.23 +-- +-- Host: localhost Database: Lex +--------------------------------------------------------- +-- Server version 3.23.58-max-log + +-- +-- Table structure for table `AnalyticalNotes` +-- + +CREATE TABLE AnalyticalNotes ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + analyticalNote text, + PRIMARY KEY (metaId), + KEY parentId (parentId), + KEY metaId (metaId) +) TYPE=MyISAM; + +-- +-- Table structure for table `Authors` +-- + +CREATE TABLE Authors ( + id int(11) NOT NULL auto_increment, + author mediumtext NOT NULL, + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `Definitions` +-- + +CREATE TABLE Definitions ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) NOT NULL default '0', + definition text, + PRIMARY KEY (metaId), + KEY parentId (parentId), + KEY metaId (metaId) +) TYPE=MyISAM; + +-- +-- Table structure for table `Dialects` +-- + +CREATE TABLE Dialects ( + id int(11) NOT NULL auto_increment, + majorDialectFamily smallint(6) NOT NULL default '0', + specificDialect smallint(6) NOT NULL default '0', + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `EncyclopediaArticles` +-- + +CREATE TABLE EncyclopediaArticles ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + article text NOT NULL, + articleTitle text NOT NULL, + PRIMARY KEY (metaId), + KEY parentId (parentId), + KEY metaId (metaId) +) TYPE=MyISAM; + +-- +-- Table structure for table `Etymologies` +-- + +CREATE TABLE Etymologies ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + loanLanguage smallint(6) default NULL, + etymologyType smallint(6) NOT NULL default '0', + derivation varchar(255) NOT NULL default '', + etymologyDescription text NOT NULL, + PRIMARY KEY (metaId), + KEY metaId (metaId), + KEY parentId (parentId) +) TYPE=MyISAM; + +-- +-- Table structure for table `EtymologyTypes` +-- + +CREATE TABLE EtymologyTypes ( + id int(11) NOT NULL auto_increment, + etymologyType varchar(255) NOT NULL default '', + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `Functions` +-- + +CREATE TABLE Functions ( + id int(11) NOT NULL auto_increment, + functionsGeneral smallint(6) NOT NULL default '0', + functionsSpecific smallint(6) NOT NULL default '0', + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `FunctionsGeneral` +-- + +CREATE TABLE FunctionsGeneral ( + id int(11) NOT NULL auto_increment, + functionGeneral varchar(255) NOT NULL default '', + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `FunctionsSpecific` +-- + +CREATE TABLE FunctionsSpecific ( + id int(11) NOT NULL auto_increment, + functionSpecific varchar(255) NOT NULL default '', + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `Glosses` +-- + +CREATE TABLE Glosses ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + gloss text, + translation text, + PRIMARY KEY (metaId), + KEY metaId (metaId), + KEY parentId (parentId) +) TYPE=MyISAM; + +-- +-- Table structure for table `GrammaticalFunctions` +-- + +CREATE TABLE GrammaticalFunctions ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + function smallint(6) NOT NULL default '0', + PRIMARY KEY (metaId), + KEY metaId (metaId), + KEY parentId (parentId) +) TYPE=MyISAM; + +-- +-- Table structure for table `Keywords` +-- + +CREATE TABLE Keywords ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + keyword text, + PRIMARY KEY (metaId), + KEY parentId (parentId), + KEY metaId (metaId) +) TYPE=MyISAM; + +-- +-- Table structure for table `Languages` +-- + +CREATE TABLE Languages ( + id int(11) NOT NULL auto_increment, + language varchar(255) NOT NULL default '', + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `LiteraryForms` +-- + +CREATE TABLE LiteraryForms ( + id int(11) NOT NULL auto_increment, + literaryForm mediumtext NOT NULL, + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `LiteraryGenres` +-- + +CREATE TABLE LiteraryGenres ( + id int(11) NOT NULL auto_increment, + literaryGenre mediumtext NOT NULL, + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `LiteraryPeriods` +-- + +CREATE TABLE LiteraryPeriods ( + id int(11) NOT NULL auto_increment, + literaryPeriod mediumtext NOT NULL, + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `LiteraryQuotations` +-- + +CREATE TABLE LiteraryQuotations ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + literarySource text, + spelling text, + pagination text, + passage text, + PRIMARY KEY (metaId), + KEY parentId (parentId), + KEY metaId (metaId) +) TYPE=MyISAM; + +-- +-- Table structure for table `LiterarySources` +-- + +CREATE TABLE LiterarySources ( + id int(11) NOT NULL auto_increment, + literaryPeriod int(11) default NULL, + literaryGenre int(11) default NULL, + literaryForm int(11) default NULL, + author int(11) default NULL, + sourceNormalizedTitle mediumtext, + tibetanDate mediumtext, + internationalDate mediumtext, + edition mediumtext, + publisher mediumtext, + isbn mediumtext, + yearPublished timestamp(14) NOT NULL, + volumeNumber int(11) NOT NULL default '0', + pagination mediumtext, + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `MajorDialectFamilies` +-- + +CREATE TABLE MajorDialectFamilies ( + id int(11) NOT NULL auto_increment, + majorDialectFamily mediumtext, + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `Meta` +-- + +CREATE TABLE Meta ( + metaId int(11) NOT NULL auto_increment, + translationOf int(11) default NULL, + deleted tinyint(1) NOT NULL default '0', + createdBy int(11) NOT NULL default '0', + modifiedBy int(11) NOT NULL default '0', + createdByProjSub int(11) NOT NULL default '0', + modifiedByProjSub int(11) NOT NULL default '0', + createdOn datetime default NULL, + modifiedOn datetime default NULL, + source int(11) NOT NULL default '0', + language smallint(6) NOT NULL default '0', + script smallint(6) NOT NULL default '0', + dialect smallint(6) NOT NULL default '0', + note text, + PRIMARY KEY (metaId), + KEY translationOf (translationOf) +) TYPE=MyISAM; + +-- +-- Table structure for table `ModelSentences` +-- + +CREATE TABLE ModelSentences ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + subdefinitionId int(11) NOT NULL default '0', + modelSentence text, + PRIMARY KEY (metaId), + KEY metaId (metaId), + KEY parentId (parentId) +) TYPE=MyISAM; + +-- +-- Table structure for table `PhoneticsTypes` +-- + +CREATE TABLE PhoneticsTypes ( + id int(11) NOT NULL auto_increment, + phoneticsType varchar(255) NOT NULL default '', + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `Preferences` +-- + +CREATE TABLE Preferences ( + id int(11) NOT NULL auto_increment, + userId int(11) NOT NULL default '0', + preferencesName int(11) default NULL, + projectSubject int(11) default NULL, + source int(11) default NULL, + language int(11) default NULL, + script int(11) default NULL, + dialect int(11) default NULL, + note mediumtext, + useDefaultProjSub varchar(5) NOT NULL default 'false', + useDefaultSource varchar(5) NOT NULL default 'false', + useDefaultLanguage varchar(5) NOT NULL default 'false', + useDefaultScript varchar(5) NOT NULL default 'false', + useDefaultDialect varchar(5) NOT NULL default 'false', + useDefaultNote varchar(5) NOT NULL default 'false', + projectSubjectSet varchar(255) default NULL, + sourceSet varchar(255) default NULL, + languageSet varchar(255) default NULL, + scriptSet varchar(255) default NULL, + dialectSet varchar(255) default NULL, + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `ProjectSubjects` +-- + +CREATE TABLE ProjectSubjects ( + id int(11) NOT NULL auto_increment, + projectSubject varchar(255) default NULL, + leader int(11) NOT NULL default '0', + participantList mediumtext, + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `Pronunciations` +-- + +CREATE TABLE Pronunciations ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + phonetics text NOT NULL, + phoneticsType smallint(6) NOT NULL default '0', + PRIMARY KEY (metaId), + KEY metaId (metaId), + KEY parentId (parentId) +) TYPE=MyISAM; + +-- +-- Table structure for table `Registers` +-- + +CREATE TABLE Registers ( + id int(11) NOT NULL auto_increment, + register mediumtext NOT NULL, + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `RelatedTermTypes` +-- + +CREATE TABLE RelatedTermTypes ( + id int(11) NOT NULL auto_increment, + relatedTermType varchar(255) NOT NULL default '', + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `RelatedTerms` +-- + +CREATE TABLE RelatedTerms ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + relatedTerm text, + relatedTermType smallint(6) NOT NULL default '0', + PRIMARY KEY (metaId), + KEY parentId (parentId), + KEY metaId (metaId) +) TYPE=MyISAM; + +-- +-- Table structure for table `Scripts` +-- + +CREATE TABLE Scripts ( + id int(11) NOT NULL auto_increment, + script varchar(255) NOT NULL default '', + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `Sources` +-- + +CREATE TABLE Sources ( + id int(11) NOT NULL auto_increment, + sourceTitle mediumtext NOT NULL, + sourceDescription mediumtext, + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `SpecificDialects` +-- + +CREATE TABLE SpecificDialects ( + id int(11) NOT NULL auto_increment, + specificDialect mediumtext, + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `SpeechRegisters` +-- + +CREATE TABLE SpeechRegisters ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + register smallint(6) NOT NULL default '0', + PRIMARY KEY (metaId), + KEY metaId (metaId), + KEY parentId (parentId) +) TYPE=MyISAM; + +-- +-- Table structure for table `SpellingTypes` +-- + +CREATE TABLE SpellingTypes ( + id int(11) NOT NULL auto_increment, + spellingType varchar(255) NOT NULL default '', + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `Spellings` +-- + +CREATE TABLE Spellings ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + spelling varchar(255) NOT NULL default '', + spellingType smallint(6) NOT NULL default '0', + PRIMARY KEY (metaId), + KEY parentId (parentId), + KEY metaId (metaId) +) TYPE=MyISAM; + +-- +-- Table structure for table `Subdefinitions` +-- + +CREATE TABLE Subdefinitions ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + subdefinition text, + PRIMARY KEY (metaId), + KEY metaId (metaId), + KEY parentId (parentId) +) TYPE=MyISAM; + +-- +-- Table structure for table `Terms` +-- + +CREATE TABLE Terms ( + metaId int(11) NOT NULL default '0', + term varchar(255) NOT NULL default '', + precedence smallint(6) default NULL, + PRIMARY KEY (metaId), + KEY metaId (metaId) +) TYPE=MyISAM; + +-- +-- Table structure for table `TransitionalData` +-- + +CREATE TABLE TransitionalData ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + transitionalDataLabel smallint(6) default NULL, + forPublicConsumption varchar(5) NOT NULL default '', + transitionalDataText text, + PRIMARY KEY (metaId), + KEY metaId (metaId), + KEY parentId (parentId) +) TYPE=MyISAM; + +-- +-- Table structure for table `TransitionalDataLabels` +-- + +CREATE TABLE TransitionalDataLabels ( + id int(11) NOT NULL auto_increment, + transitionalDataLabel mediumtext, + PRIMARY KEY (id) +) TYPE=MyISAM; + +-- +-- Table structure for table `TranslationEquivalents` +-- + +CREATE TABLE TranslationEquivalents ( + metaId int(11) NOT NULL default '0', + parentId int(11) default NULL, + precedence smallint(6) default NULL, + translationEquivalent text, + PRIMARY KEY (metaId), + KEY metaId (metaId), + KEY parentId (parentId) +) TYPE=MyISAM; + +-- +-- Table structure for table `Users` +-- + +CREATE TABLE Users ( + id int(11) NOT NULL auto_increment, + metaId int(11) NOT NULL default '0', + userRoleList varchar(255) default NULL, + username varchar(255) NOT NULL default '', + password varchar(255) NOT NULL default '', + firstname varchar(255) NOT NULL default '', + lastname varchar(255) NOT NULL default '', + middlename varchar(255) NOT NULL default '', + title varchar(255) NOT NULL default '', + email varchar(255) NOT NULL default '', + PRIMARY KEY (id) +) TYPE=MyISAM; + diff --git a/src/sql/lex-schema.sql b/src/sql/lex-schema.sql new file mode 100644 index 0000000..99a6598 --- /dev/null +++ b/src/sql/lex-schema.sql @@ -0,0 +1,344 @@ +drop table if exists FunctionsGeneral; +drop table if exists LiteraryPeriods; +drop table if exists Registers; +drop table if exists Pronunciations; +drop table if exists Authors; +drop table if exists Keywords; +drop table if exists Glosses; +drop table if exists RelatedTerms; +drop table if exists PhoneticsTypes; +drop table if exists Etymologies; +drop table if exists Meta; +drop table if exists SpellingTypes; +drop table if exists Dialects; +drop table if exists TransitionalData; +drop table if exists LiterarySources; +drop table if exists Spellings; +drop table if exists AnalyticalNotes; +drop table if exists EtymologyTypes; +drop table if exists SpeechRegisters; +drop table if exists Definitions; +drop table if exists FunctionsSpecific; +drop table if exists RelatedTermTypes; +drop table if exists ProjectSubjects; +drop table if exists ModelSentences; +drop table if exists Subdefinitions; +drop table if exists LiteraryGenres; +drop table if exists GrammaticalFunctions; +drop table if exists Functions; +drop table if exists SpecificDialects; +drop table if exists Sources; +drop table if exists TransitionalDataLabels; +drop table if exists LiteraryForms; +drop table if exists EncyclopediaArticles; +drop table if exists LiteraryQuotations; +drop table if exists MajorDialectFamilies; +drop table if exists Terms; +drop table if exists Scripts; +drop table if exists Languages; +drop table if exists TranslationEquivalents; +create table FunctionsGeneral ( + id SMALLINT NOT NULL AUTO_INCREMENT, + functionGeneral VARCHAR(255) not null, + primary key (id) +); +create table LiteraryPeriods ( + id INTEGER NOT NULL AUTO_INCREMENT, + literaryPeriod TEXT not null, + primary key (id) +); +create table Registers ( + id SMALLINT NOT NULL AUTO_INCREMENT, + register TEXT not null, + primary key (id) +); +create table Pronunciations ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + phonetics TEXT not null, + phoneticsType SMALLINT not null, + primary key (metaId) +); +create table Authors ( + id INTEGER NOT NULL AUTO_INCREMENT, + author TEXT not null, + primary key (id) +); +create table Keywords ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + keyword TEXT, + primary key (metaId) +); +create table Glosses ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + gloss TEXT, + translation TEXT, + primary key (metaId) +); +create table RelatedTerms ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + relatedTerm TEXT, + relatedTermType SMALLINT not null, + primary key (metaId) +); +create table PhoneticsTypes ( + id SMALLINT NOT NULL AUTO_INCREMENT, + phoneticsType VARCHAR(255) not null, + primary key (id) +); +create table Etymologies ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + loanLanguage SMALLINT, + etymologyType SMALLINT not null, + derivation VARCHAR(255) not null, + etymologyDescription TEXT not null, + primary key (metaId) +); +create table Meta ( + metaId INTEGER NOT NULL AUTO_INCREMENT, + translationOf INTEGER, + deleted BIT not null, + createdBy INTEGER not null, + modifiedBy INTEGER not null, + createdByProjSub INTEGER not null, + modifiedByProjSub INTEGER not null, + createdOn DATETIME, + modifiedOn DATETIME, + source INTEGER not null, + language SMALLINT not null, + script SMALLINT not null, + dialect SMALLINT not null, + note TEXT, + primary key (metaId) +); +create table SpellingTypes ( + id SMALLINT NOT NULL AUTO_INCREMENT, + spellingType VARCHAR(255) not null, + primary key (id) +); +create table Dialects ( + id INTEGER NOT NULL AUTO_INCREMENT, + majorDialectFamily SMALLINT not null, + specificDialect SMALLINT not null, + primary key (id) +); +create table TransitionalData ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + transitionalDataLabel SMALLINT, + forPublicConsumption VARCHAR(5) not null, + transitionalDataText TEXT, + primary key (metaId) +); +create table LiterarySources ( + id INTEGER NOT NULL AUTO_INCREMENT, + literaryPeriod INTEGER, + literaryGenre INTEGER, + literaryForm INTEGER, + author INTEGER, + sourceNormalizedTitle TEXT, + tibetanDate TEXT, + internationalDate TEXT, + edition TEXT, + publisher TEXT, + isbn TEXT, + yearPublished DATETIME, + volumeNumber INTEGER not null, + pagination TEXT, + primary key (id) +); +create table Spellings ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + spelling VARCHAR(255) not null, + spellingType SMALLINT not null, + primary key (metaId) +); +create table AnalyticalNotes ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + analyticalNote TEXT, + primary key (metaId) +); +create table EtymologyTypes ( + id SMALLINT NOT NULL AUTO_INCREMENT, + etymologyType VARCHAR(255) not null, + primary key (id) +); +create table SpeechRegisters ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + register SMALLINT not null, + primary key (metaId) +); +create table Definitions ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT not null, + definition TEXT, + primary key (metaId) +); +create table FunctionsSpecific ( + id SMALLINT NOT NULL AUTO_INCREMENT, + functionSpecific VARCHAR(255) not null, + primary key (id) +); +create table RelatedTermTypes ( + id SMALLINT NOT NULL AUTO_INCREMENT, + relatedTermType VARCHAR(255) not null, + primary key (id) +); +create table ProjectSubjects ( + id INTEGER NOT NULL AUTO_INCREMENT, + projectSubject VARCHAR(255), + leader INTEGER not null, + participantList TEXT, + primary key (id) +); +create table ModelSentences ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + subdefinitionId INTEGER not null, + modelSentence TEXT, + primary key (metaId) +); +create table Subdefinitions ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + subdefinition TEXT, + primary key (metaId) +); +create table LiteraryGenres ( + id INTEGER NOT NULL AUTO_INCREMENT, + literaryGenre TEXT not null, + primary key (id) +); +create table GrammaticalFunctions ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + function SMALLINT not null, + primary key (metaId) +); +create table Functions ( + id SMALLINT NOT NULL AUTO_INCREMENT, + functionsGeneral SMALLINT not null, + functionsSpecific SMALLINT not null, + primary key (id) +); +create table SpecificDialects ( + id SMALLINT NOT NULL AUTO_INCREMENT, + specificDialect TEXT, + primary key (id) +); +create table Sources ( + id INTEGER NOT NULL AUTO_INCREMENT, + sourceTitle TEXT not null, + sourceDescription TEXT, + primary key (id) +); +create table TransitionalDataLabels ( + id SMALLINT NOT NULL AUTO_INCREMENT, + transitionalDataLabel TEXT, + primary key (id) +); +create table LiteraryForms ( + id INTEGER NOT NULL AUTO_INCREMENT, + literaryForm TEXT not null, + primary key (id) +); +create table EncyclopediaArticles ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + article TEXT not null, + articleTitle TEXT not null, + primary key (metaId) +); +create table LiteraryQuotations ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + literarySource TEXT, + spelling TEXT, + pagination TEXT, + passage TEXT, + primary key (metaId) +); +create table MajorDialectFamilies ( + id SMALLINT NOT NULL AUTO_INCREMENT, + majorDialectFamily TEXT, + primary key (id) +); +create table Terms ( + metaId INTEGER not null, + term VARCHAR(255) not null, + precedence SMALLINT, + primary key (metaId) +); +create table Scripts ( + id SMALLINT NOT NULL AUTO_INCREMENT, + script VARCHAR(255) not null, + primary key (id) +); +create table Languages ( + id SMALLINT NOT NULL AUTO_INCREMENT, + language VARCHAR(255) not null, + primary key (id) +); +create table TranslationEquivalents ( + metaId INTEGER not null, + parentId INTEGER, + precedence SMALLINT, + translationEquivalent TEXT, + primary key (metaId) +); +alter table Pronunciations add index (metaId), add constraint FK1889BDEBFC5B200 foreign key (metaId) references Meta (metaId); +alter table Pronunciations add index (parentId), add constraint FK1889BDE460B8F65 foreign key (parentId) references Terms (metaId); +alter table Keywords add index (parentId), add constraint FK230903CA460B8F65 foreign key (parentId) references Subdefinitions (metaId); +alter table Keywords add index (metaId), add constraint FK230903CABFC5B200 foreign key (metaId) references Meta (metaId); +alter table Glosses add index (metaId), add constraint FK6A780618BFC5B200 foreign key (metaId) references Meta (metaId); +alter table Glosses add index (parentId), add constraint FK6A780618460B8F65 foreign key (parentId) references Subdefinitions (metaId); +alter table RelatedTerms add index (parentId), add constraint FK125CF43C460B8F65 foreign key (parentId) references Subdefinitions (metaId); +alter table RelatedTerms add index (metaId), add constraint FK125CF43CBFC5B200 foreign key (metaId) references Meta (metaId); +alter table Etymologies add index (metaId), add constraint FKD08FB0BFBFC5B200 foreign key (metaId) references Meta (metaId); +alter table Etymologies add index (parentId), add constraint FKD08FB0BF460B8F65 foreign key (parentId) references Terms (metaId); +alter table Meta add index (translationOf), add constraint FK248A2527981468 foreign key (translationOf) references Meta (metaId); +alter table TransitionalData add index (metaId), add constraint FK9204002ABFC5B200 foreign key (metaId) references Meta (metaId); +alter table TransitionalData add index (parentId), add constraint FK9204002A460B8F65 foreign key (parentId) references Terms (metaId); +alter table Spellings add index (parentId), add constraint FK21F7B1D9460B8F65 foreign key (parentId) references Terms (metaId); +alter table Spellings add index (metaId), add constraint FK21F7B1D9BFC5B200 foreign key (metaId) references Meta (metaId); +alter table AnalyticalNotes add index (parentId), add constraint FK5226AE09460B8F65 foreign key (parentId) references Meta (metaId); +alter table AnalyticalNotes add index (metaId), add constraint FK5226AE09BFC5B200 foreign key (metaId) references Meta (metaId); +alter table SpeechRegisters add index (metaId), add constraint FK6456534EBFC5B200 foreign key (metaId) references Meta (metaId); +alter table SpeechRegisters add index (parentId), add constraint FK6456534E460B8F65 foreign key (parentId) references Subdefinitions (metaId); +alter table Definitions add index (parentId), add constraint FK11071D60460B8F65 foreign key (parentId) references Terms (metaId); +alter table Definitions add index (metaId), add constraint FK11071D60BFC5B200 foreign key (metaId) references Meta (metaId); +alter table ModelSentences add index (metaId), add constraint FKBDC96567BFC5B200 foreign key (metaId) references Meta (metaId); +alter table ModelSentences add index (parentId), add constraint FKBDC96567460B8F65 foreign key (parentId) references Subdefinitions (metaId); +alter table Subdefinitions add index (metaId), add constraint FKDC691B60BFC5B200 foreign key (metaId) references Meta (metaId); +alter table Subdefinitions add index (parentId), add constraint FKDC691B60460B8F65 foreign key (parentId) references Definitions (metaId); +alter table GrammaticalFunctions add index (metaId), add constraint FKCD3F816DBFC5B200 foreign key (metaId) references Meta (metaId); +alter table GrammaticalFunctions add index (parentId), add constraint FKCD3F816D460B8F65 foreign key (parentId) references Terms (metaId); +alter table EncyclopediaArticles add index (parentId), add constraint FKAC14CB5D460B8F65 foreign key (parentId) references Terms (metaId); +alter table EncyclopediaArticles add index (metaId), add constraint FKAC14CB5DBFC5B200 foreign key (metaId) references Meta (metaId); +alter table LiteraryQuotations add index (parentId), add constraint FK99D4FE0B460B8F65 foreign key (parentId) references Subdefinitions (metaId); +alter table LiteraryQuotations add index (metaId), add constraint FK99D4FE0BBFC5B200 foreign key (metaId) references Meta (metaId); +alter table Terms add index (metaId), add constraint FK4CF5967BFC5B200 foreign key (metaId) references Meta (metaId); +alter table TranslationEquivalents add index (metaId), add constraint FK27FEF3F8BFC5B200 foreign key (metaId) references Meta (metaId); +alter table TranslationEquivalents add index (parentId), add constraint FK27FEF3F8460B8F65 foreign key (parentId) references Subdefinitions (metaId);