Remove superfluous conditional return.
[online-glom:gwt-glom.git] / src / main / java / org / glom / web / server / OnlineGlomServiceImpl.java
1 /*
2  * Copyright (C) 2010, 2011 Openismus GmbH
3  *
4  * This file is part of GWT-Glom.
5  *
6  * GWT-Glom is free software: you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as published by the
8  * Free Software Foundation, either version 3 of the License, or (at your
9  * option) any later version.
10  *
11  * GWT-Glom is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
14  * for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with GWT-Glom.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 package org.glom.web.server;
21
22 import java.beans.PropertyVetoException;
23 import java.io.File;
24 import java.io.FilenameFilter;
25 import java.io.IOException;
26 import java.io.InputStream;
27 import java.sql.Connection;
28 import java.sql.Date;
29 import java.sql.ResultSet;
30 import java.sql.SQLException;
31 import java.sql.Statement;
32 import java.sql.Time;
33 import java.text.DateFormat;
34 import java.text.NumberFormat;
35 import java.util.ArrayList;
36 import java.util.Currency;
37 import java.util.Hashtable;
38 import java.util.Locale;
39 import java.util.Properties;
40
41 import org.glom.libglom.BakeryDocument.LoadFailureCodes;
42 import org.glom.libglom.Document;
43 import org.glom.libglom.Field;
44 import org.glom.libglom.FieldFormatting;
45 import org.glom.libglom.FieldVector;
46 import org.glom.libglom.Glom;
47 import org.glom.libglom.LayoutFieldVector;
48 import org.glom.libglom.LayoutGroupVector;
49 import org.glom.libglom.LayoutItem;
50 import org.glom.libglom.LayoutItemVector;
51 import org.glom.libglom.LayoutItem_Field;
52 import org.glom.libglom.LayoutItem_Portal;
53 import org.glom.libglom.NumericFormat;
54 import org.glom.libglom.SortClause;
55 import org.glom.libglom.SortFieldPair;
56 import org.glom.libglom.StringVector;
57 import org.glom.web.client.OnlineGlomService;
58 import org.glom.web.shared.ColumnInfo;
59 import org.glom.web.shared.GlomDocument;
60 import org.glom.web.shared.GlomField;
61 import org.glom.web.shared.LayoutListTable;
62 import org.glom.web.shared.layout.LayoutGroup;
63 import org.glom.web.shared.layout.LayoutItemField;
64
65 import com.allen_sauer.gwt.log.client.Log;
66 import com.google.gwt.user.server.rpc.RemoteServiceServlet;
67 import com.mchange.v2.c3p0.ComboPooledDataSource;
68 import com.mchange.v2.c3p0.DataSources;
69
70 @SuppressWarnings("serial")
71 public class OnlineGlomServiceImpl extends RemoteServiceServlet implements OnlineGlomService {
72
73         // class to hold configuration information for related to the glom document and db access
74         private class ConfiguredDocument {
75                 private Document document;
76                 private ComboPooledDataSource cpds;
77                 private boolean authenticated = false;
78
79                 // @formatter:off
80                 public Document getDocument() { return document; }
81                 public void setDocument(Document document) { this.document = document; }
82                 public ComboPooledDataSource getCpds() { return cpds; }
83                 public void setCpds(ComboPooledDataSource cpds) { this.cpds = cpds;     }
84                 public boolean isAuthenticated() { return authenticated; }
85                 public void setAuthenticated(boolean authenticated) { this.authenticated = authenticated; }
86                 // @formatter:on
87         }
88
89         // convenience class to for dealing with the Online Glom configuration file
90         private class OnlineGlomProperties extends Properties {
91                 public String getKey(String value) {
92                         for (String key : stringPropertyNames()) {
93                                 if (getProperty(key).trim().equals(value))
94                                         return key;
95                         }
96                         return null;
97                 }
98         }
99
100         private final Hashtable<String, ConfiguredDocument> documents = new Hashtable<String, ConfiguredDocument>();
101         // TODO implement locale
102         private final Locale locale = Locale.ROOT;
103
104         /*
105          * This is called when the servlet is started or restarted.
106          */
107         public OnlineGlomServiceImpl() throws Exception {
108
109                 // Find the configuration file. See this thread for background info:
110                 // http://stackoverflow.com/questions/2161054/where-to-place-properties-files-in-a-jsp-servlet-web-application
111                 OnlineGlomProperties config = new OnlineGlomProperties();
112                 InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("onlineglom.properties");
113                 if (is == null) {
114                         Log.fatal(Thread.currentThread().getStackTrace()[1].getMethodName() + ": "
115                                         + "onlineglom.properties not found.");
116                         throw new IOException();
117                 }
118                 config.load(is);
119
120                 // check the configured glom file directory
121                 String documentDirName = config.getProperty("glom.document.directory");
122                 File documentDir = new File(documentDirName);
123                 if (!documentDir.isDirectory()) {
124                         Log.fatal(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentDirName
125                                         + " is not a directory.");
126                         throw new IOException();
127                 }
128                 if (!documentDir.canRead()) {
129                         Log.fatal(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + "Can't read the files in : "
130                                         + documentDirName);
131                         throw new IOException();
132                 }
133
134                 // get and check the glom files in the specified directory
135                 File[] glomFiles = documentDir.listFiles(new FilenameFilter() {
136                         @Override
137                         public boolean accept(File dir, String name) {
138                                 return name.endsWith(".glom");
139                         }
140                 });
141                 Glom.libglom_init();
142                 for (File glomFile : glomFiles) {
143                         Document document = new Document();
144                         document.set_file_uri("file://" + glomFile.getAbsolutePath());
145                         int error = 0;
146                         boolean retval = document.load(error);
147                         if (retval == false) {
148                                 String message;
149                                 if (LoadFailureCodes.LOAD_FAILURE_CODE_NOT_FOUND == LoadFailureCodes.swigToEnum(error)) {
150                                         message = "Could not find " + documentDir.getAbsolutePath();
151                                 } else {
152                                         message = "An unknown error occurred when trying to load " + documentDir.getAbsolutePath();
153                                 }
154                                 Log.error(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + message);
155                                 // continue with for loop because there may be other documents in the directory
156                                 continue;
157                         }
158
159                         // load the jdbc driver for the current glom document
160                         ComboPooledDataSource cpds = new ComboPooledDataSource();
161
162                         try {
163                                 cpds.setDriverClass("org.postgresql.Driver");
164                         } catch (PropertyVetoException e) {
165                                 Log.fatal(Thread.currentThread().getStackTrace()[1].getMethodName()
166                                                 + ": "
167                                                 + "Error loading the PostgreSQL JDBC driver. Is the PostgreSQL JDBC jar available to the servlet?");
168                                 throw e;
169                         }
170
171                         // setup the JDBC driver for the current glom document
172                         cpds.setJdbcUrl("jdbc:postgresql://" + document.get_connection_server() + "/"
173                                         + document.get_connection_database());
174
175                         // check if a username and password have been set and work for the current document
176                         String documentTitle = document.get_database_title().trim();
177                         ConfiguredDocument configuredDocument = new ConfiguredDocument();
178                         String key = config.getKey(documentTitle);
179                         if (key != null) {
180                                 String[] keyArray = key.split("\\.");
181                                 if (keyArray.length == 3 && "title".equals(keyArray[2])) {
182                                         // username/password could be set, let's check to see if it works
183                                         String usernameKey = key.replaceAll(keyArray[2], "username");
184                                         String passwordKey = key.replaceAll(keyArray[2], "password");
185                                         configuredDocument.setAuthenticated(checkAuthentication(documentTitle, cpds,
186                                                         config.getProperty(usernameKey), config.getProperty(passwordKey)));
187                                 }
188                         }
189
190                         // check the if the global username and password have been set and work with this document
191                         if (!configuredDocument.isAuthenticated()) {
192                                 configuredDocument.setAuthenticated(checkAuthentication(documentTitle, cpds,
193                                                 config.getProperty("glom.document.username"), config.getProperty("glom.document.password")));
194                         }
195
196                         // add information to the hash table
197                         configuredDocument.setDocument(document);
198                         configuredDocument.setCpds(cpds);
199                         documents.put(documentTitle, configuredDocument);
200                 }
201         }
202
203         /*
204          * Checks if the username and password works with the database configured with the specified ComboPooledDataSource.
205          * 
206          * @return true if authentication works, false otherwise
207          */
208         private boolean checkAuthentication(String documentTitle, ComboPooledDataSource cpds, String username,
209                         String password) throws SQLException {
210                 cpds.setUser(username);
211                 cpds.setPassword(password);
212
213                 int acquireRetryAttempts = cpds.getAcquireRetryAttempts();
214                 cpds.setAcquireRetryAttempts(1);
215                 Connection conn = null;
216                 try {
217                         // FIXME find a better way to check authentication
218                         // it's possible that the connection could be failing for another reason
219                         conn = cpds.getConnection();
220                         return true;
221                 } catch (SQLException e) {
222                         Log.info(Thread.currentThread().getStackTrace()[1].getMethodName() + ": "
223                                         + "Username and password not correct for document: " + documentTitle);
224                 } finally {
225                         if (conn != null)
226                                 conn.close();
227                         cpds.setAcquireRetryAttempts(acquireRetryAttempts);
228                 }
229                 return false;
230         }
231
232         /*
233          * This is called when the servlet is stopped or restarted.
234          * 
235          * @see javax.servlet.GenericServlet#destroy()
236          */
237         @Override
238         public void destroy() {
239                 Glom.libglom_deinit();
240
241                 for (String documenTitle : documents.keySet()) {
242                         ConfiguredDocument configuredDoc = documents.get(documenTitle);
243                         try {
244                                 DataSources.destroy(configuredDoc.getCpds());
245                         } catch (SQLException e) {
246                                 Log.error(Thread.currentThread().getStackTrace()[1].getMethodName() + ": "
247                                                 + "Error cleaning up the ComboPooledDataSource for " + documenTitle, e);
248                         }
249                 }
250
251         }
252
253         public GlomDocument getGlomDocument(String documentTitle) {
254
255                 Document document = documents.get(documentTitle).getDocument();
256                 GlomDocument glomDocument = new GlomDocument();
257
258                 // get arrays of table names and titles, and find the default table index
259                 StringVector tablesVec = document.get_table_names();
260
261                 int numTables = safeLongToInt(tablesVec.size());
262                 // we don't know how many tables will be hidden so we'll use half of the number of tables for the default size
263                 // of the ArrayList
264                 ArrayList<String> tableNames = new ArrayList<String>(numTables / 2);
265                 ArrayList<String> tableTitles = new ArrayList<String>(numTables / 2);
266                 boolean foundDefaultTable = false;
267                 int visibleIndex = 0;
268                 for (int i = 0; i < numTables; i++) {
269                         String tableName = tablesVec.get(i);
270                         if (!document.get_table_is_hidden(tableName)) {
271                                 tableNames.add(tableName);
272                                 // JNI is "expensive", the comparison will only be called if we haven't already found the default table
273                                 if (!foundDefaultTable && tableName.equals(document.get_default_table())) {
274                                         glomDocument.setDefaultTableIndex(visibleIndex);
275                                         foundDefaultTable = true;
276                                 }
277                                 tableTitles.add(document.get_table_title(tableName));
278                                 visibleIndex++;
279                         }
280                 }
281
282                 // set everything we need
283                 glomDocument.setTableNames(tableNames);
284                 glomDocument.setTableTitles(tableTitles);
285
286                 return glomDocument;
287         }
288
289         /*
290          * (non-Javadoc)
291          * 
292          * @see org.glom.web.client.OnlineGlomService#getDefaultLayoutListTable(java.lang.String)
293          */
294         @Override
295         public LayoutListTable getDefaultLayoutListTable(String documentTitle) {
296                 GlomDocument glomDocument = getGlomDocument(documentTitle);
297                 String tableName = glomDocument.getTableNames().get(glomDocument.getDefaultTableIndex());
298                 LayoutListTable layoutListTable = getLayoutListTable(documentTitle, tableName);
299                 layoutListTable.setTableName(tableName);
300                 return layoutListTable;
301         }
302
303         public LayoutListTable getLayoutListTable(String documentTitle, String table) {
304                 ConfiguredDocument configuredDoc = documents.get(documentTitle);
305                 Document document = configuredDoc.getDocument();
306                 LayoutListTable tableInfo = new LayoutListTable();
307
308                 // access the layout list
309                 LayoutGroupVector layoutListVec = document.get_data_layout_groups("list", table);
310                 ColumnInfo[] columns = null;
311                 LayoutFieldVector layoutFields = new LayoutFieldVector();
312                 int listViewLayoutGroupSize = safeLongToInt(layoutListVec.size());
313                 if (listViewLayoutGroupSize > 0) {
314                         // a layout list is defined, we can use it to for the LayoutListTable
315                         if (listViewLayoutGroupSize > 1)
316                                 Log.warn(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
317                                                 + table + ": The size of the list view layout group for table " + table
318                                                 + " is greater than 1. Attempting to use the first item for the layout list view.");
319                         LayoutItemVector layoutItemsVec = layoutListVec.get(0).get_items();
320
321                         // find the defined layout list fields
322                         int numItems = safeLongToInt(layoutItemsVec.size());
323                         columns = new ColumnInfo[numItems];
324                         for (int i = 0; i < numItems; i++) {
325                                 // TODO add support for other LayoutItems (Text, Image, Button)
326                                 LayoutItem item = layoutItemsVec.get(i);
327                                 LayoutItem_Field layoutItemField = LayoutItem_Field.cast_dynamic(item);
328                                 if (layoutItemField != null) {
329                                         layoutFields.add(layoutItemField);
330                                         columns[i] = new ColumnInfo(
331                                                         layoutItemField.get_title_or_name(),
332                                                         getColumnInfoHorizontalAlignment(layoutItemField.get_formatting_used_horizontal_alignment()),
333                                                         getColumnInfoGlomFieldType(layoutItemField.get_glom_type()));
334                                 }
335                         }
336                 } else {
337                         // no layout list is defined, use the table fields as the layout list
338                         FieldVector fieldsVec = document.get_table_fields(table);
339
340                         // find the fields to display in the layout list
341                         int numItems = safeLongToInt(fieldsVec.size());
342                         columns = new ColumnInfo[numItems];
343                         for (int i = 0; i < numItems; i++) {
344                                 Field field = fieldsVec.get(i);
345                                 LayoutItem_Field layoutItemField = new LayoutItem_Field();
346                                 layoutItemField.set_full_field_details(field);
347                                 layoutFields.add(layoutItemField);
348                                 columns[i] = new ColumnInfo(layoutItemField.get_title_or_name(),
349                                                 getColumnInfoHorizontalAlignment(layoutItemField.get_formatting_used_horizontal_alignment()),
350                                                 getColumnInfoGlomFieldType(layoutItemField.get_glom_type()));
351                         }
352                 }
353
354                 tableInfo.setColumns(columns);
355
356                 // Get the number of rows a query with the table name and layout fields would return. This is needed for the
357                 // list view pager.
358                 if (!configuredDoc.isAuthenticated())
359                         return tableInfo;
360                 Connection conn = null;
361                 Statement st = null;
362                 ResultSet rs = null;
363                 try {
364                         // Setup and execute the count query. Special care needs to be take to ensure that the results will be based
365                         // on a cursor so that large amounts of memory are not consumed when the query retrieve a large amount of
366                         // data. Here's the relevant PostgreSQL documentation:
367                         // http://jdbc.postgresql.org/documentation/83/query.html#query-with-cursor
368                         ComboPooledDataSource cpds = configuredDoc.getCpds();
369                         conn = cpds.getConnection();
370                         conn.setAutoCommit(false);
371                         st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
372                         String query = Glom.build_sql_select_count_simple(table, layoutFields);
373                         // TODO Test execution time of this query with when the number of rows in the table is large (say >
374                         // 1,000,000). Test memory usage at the same time (see the todo item in getTableData()).
375                         rs = st.executeQuery(query);
376
377                         // get the number of rows in the query
378                         rs.next();
379                         tableInfo.setNumRows(rs.getInt(1));
380
381                 } catch (SQLException e) {
382                         Log.error(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - " + table
383                                         + ": Error calculating number of rows in the query. Setting number of rows to 0.", e);
384                         tableInfo.setNumRows(0);
385                 } finally {
386                         // cleanup everything that has been used
387                         try {
388                                 if (rs != null)
389                                         rs.close();
390                                 if (st != null)
391                                         st.close();
392                                 if (conn != null)
393                                         conn.close();
394                         } catch (Exception e) {
395                                 Log.error(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
396                                                 + table + ": Error closing database resources. Subsequent database queries may not work.", e);
397                         }
398                 }
399
400                 return tableInfo;
401         }
402
403         public ArrayList<GlomField[]> getTableData(String documentTitle, String tableName, int start, int length) {
404                 return getTableData(documentTitle, tableName, start, length, false, 0, false);
405         }
406
407         public ArrayList<GlomField[]> getSortedTableData(String documentTitle, String tableName, int start, int length,
408                         int sortColumnIndex, boolean isAscending) {
409                 return getTableData(documentTitle, tableName, start, length, true, sortColumnIndex, isAscending);
410         }
411
412         private ArrayList<GlomField[]> getTableData(String documentTitle, String tableName, int start, int length,
413                         boolean useSortClause, int sortColumnIndex, boolean isAscending) {
414
415                 ConfiguredDocument configuredDoc = documents.get(documentTitle);
416                 if (!configuredDoc.isAuthenticated())
417                         return new ArrayList<GlomField[]>();
418                 Document document = configuredDoc.getDocument();
419
420                 // access the layout list using the defined layout list or the table fields if there's no layout list
421                 LayoutGroupVector layoutListVec = document.get_data_layout_groups("list", tableName);
422                 LayoutFieldVector layoutFields = new LayoutFieldVector();
423                 SortClause sortClause = new SortClause();
424                 int listViewLayoutGroupSize = safeLongToInt(layoutListVec.size());
425                 if (layoutListVec.size() > 0) {
426                         // a layout list is defined, we can use it to for the LayoutListTable
427                         if (listViewLayoutGroupSize > 1)
428                                 Log.warn(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle
429                                                 + ": The size of the list view layout group for table " + tableName
430                                                 + " is greater than 1. Attempting to use the first item for the layout list view.");
431                         LayoutItemVector layoutItemsVec = layoutListVec.get(0).get_items();
432
433                         // find the defined layout list fields
434                         int numItems = safeLongToInt(layoutItemsVec.size());
435                         for (int i = 0; i < numItems; i++) {
436                                 // TODO add support for other LayoutItems (Text, Image, Button)
437                                 LayoutItem item = layoutItemsVec.get(i);
438                                 LayoutItem_Field layoutItemfield = LayoutItem_Field.cast_dynamic(item);
439                                 if (layoutItemfield != null) {
440                                         // use this field in the layout
441                                         layoutFields.add(layoutItemfield);
442
443                                         // create a sort clause if it's a primary key and we're not asked to sort a specific column
444                                         if (!useSortClause) {
445                                                 Field details = layoutItemfield.get_full_field_details();
446                                                 if (details != null && details.get_primary_key()) {
447                                                         sortClause.addLast(new SortFieldPair(layoutItemfield, true)); // ascending
448                                                 }
449                                         }
450                                 }
451                         }
452                 } else {
453                         // no layout list is defined, use the table fields as the layout list
454                         FieldVector fieldsVec = document.get_table_fields(tableName);
455
456                         // find the fields to display in the layout list
457                         int numItems = safeLongToInt(fieldsVec.size());
458                         for (int i = 0; i < numItems; i++) {
459                                 Field field = fieldsVec.get(i);
460                                 LayoutItem_Field layoutItemField = new LayoutItem_Field();
461                                 layoutItemField.set_full_field_details(field);
462                                 layoutFields.add(layoutItemField);
463
464                                 // create a sort clause if it's a primary key and we're not asked to sort a specific column
465                                 if (!useSortClause) {
466                                         if (field.get_primary_key()) {
467                                                 sortClause.addLast(new SortFieldPair(layoutItemField, true)); // ascending
468                                         }
469                                 }
470                         }
471                 }
472
473                 // create a sort clause for the column we've been asked to sort
474                 if (useSortClause) {
475                         LayoutItem item = layoutFields.get(sortColumnIndex);
476                         LayoutItem_Field field = LayoutItem_Field.cast_dynamic(item);
477                         if (field != null)
478                                 sortClause.addLast(new SortFieldPair(field, isAscending));
479                         else {
480                                 Log.error(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
481                                                 + tableName + ": Error getting LayoutItem_Field for column index " + sortColumnIndex
482                                                 + ". Cannot create a sort clause for this column.");
483                         }
484
485                 }
486
487                 ArrayList<GlomField[]> rowsList = new ArrayList<GlomField[]>();
488                 Connection conn = null;
489                 Statement st = null;
490                 ResultSet rs = null;
491                 try {
492                         // Setup the JDBC driver and get the query. Special care needs to be take to ensure that the results will be
493                         // based on a cursor so that large amounts of memory are not consumed when the query retrieve a large amount
494                         // of data. Here's the relevant PostgreSQL documentation:
495                         // http://jdbc.postgresql.org/documentation/83/query.html#query-with-cursor
496                         ComboPooledDataSource cpds = configuredDoc.getCpds();
497                         conn = cpds.getConnection();
498                         conn.setAutoCommit(false);
499                         st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
500                         st.setFetchSize(length);
501                         String query = Glom.build_sql_select_simple(tableName, layoutFields, sortClause) + " OFFSET " + start;
502                         // TODO Test memory usage before and after we execute the query that would result in a large ResultSet.
503                         // We need to ensure that the JDBC driver is in fact returning a cursor based result set that has a low
504                         // memory footprint. Check the difference between this value before and after the query:
505                         // Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()
506                         // Test the execution time at the same time (see the todo item in getLayoutListTable()).
507                         rs = st.executeQuery(query);
508
509                         // get the results from the ResultSet
510                         rowsList = getData(documentTitle, tableName, length, layoutFields, rs);
511                 } catch (SQLException e) {
512                         Log.error(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
513                                         + tableName + ": Error executing database query.", e);
514                         // TODO: somehow notify user of problem
515                 } finally {
516                         // cleanup everything that has been used
517                         try {
518                                 if (rs != null)
519                                         rs.close();
520                                 if (st != null)
521                                         st.close();
522                                 if (conn != null)
523                                         conn.close();
524                         } catch (Exception e) {
525                                 Log.error(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
526                                                 + tableName + ": Error closing database resources. Subsequent database queries may not work.",
527                                                 e);
528                         }
529                 }
530                 return rowsList;
531         }
532
533         private ArrayList<GlomField[]> getData(String documentTitle, String tableName, int length,
534                         LayoutFieldVector layoutFields, ResultSet rs) throws SQLException {
535
536                 // get the data we've been asked for
537                 int rowCount = 0;
538                 ArrayList<GlomField[]> rowsList = new ArrayList<GlomField[]>();
539                 while (rs.next() && rowCount <= length) {
540                         int layoutFieldsSize = safeLongToInt(layoutFields.size());
541                         GlomField[] rowArray = new GlomField[layoutFieldsSize];
542                         for (int i = 0; i < layoutFieldsSize; i++) {
543                                 // make a new GlomField to set the text and colours
544                                 rowArray[i] = new GlomField();
545
546                                 // get foreground and background colours
547                                 LayoutItem_Field field = layoutFields.get(i);
548                                 FieldFormatting formatting = field.get_formatting_used();
549                                 String fgcolour = formatting.get_text_format_color_foreground();
550                                 if (!fgcolour.isEmpty())
551                                         rowArray[i].setFGColour(convertGdkColorToHtmlColour(fgcolour));
552                                 String bgcolour = formatting.get_text_format_color_background();
553                                 if (!bgcolour.isEmpty())
554                                         rowArray[i].setBGColour(convertGdkColorToHtmlColour(bgcolour));
555
556                                 // Convert the field value to a string based on the glom type. We're doing the formatting on the
557                                 // server side for now but it might be useful to move this to the client side.
558                                 switch (field.get_glom_type()) {
559                                 case TYPE_TEXT:
560                                         String text = rs.getString(i + 1);
561                                         rowArray[i].setText(text != null ? text : "");
562                                         break;
563                                 case TYPE_BOOLEAN:
564                                         rowArray[i].setBoolean(rs.getBoolean(i + 1));
565                                         break;
566                                 case TYPE_NUMERIC:
567                                         // Take care of the numeric formatting before converting the number to a string.
568                                         NumericFormat numFormatGlom = formatting.getM_numeric_format();
569                                         // There's no isCurrency() method in the glom NumericFormat class so we're assuming that the
570                                         // number should be formatted as a currency if the currency code string is not empty.
571                                         String currencyCode = numFormatGlom.getM_currency_symbol();
572                                         NumberFormat numFormatJava = null;
573                                         boolean useGlomCurrencyCode = false;
574                                         if (currencyCode.length() == 3) {
575                                                 // Try to format the currency using the Java Locales system.
576                                                 try {
577                                                         Currency currency = Currency.getInstance(currencyCode);
578                                                         Log.info(Thread.currentThread().getStackTrace()[1].getMethodName()
579                                                                         + ": "
580                                                                         + documentTitle
581                                                                         + " "
582                                                                         + tableName
583                                                                         + ": A valid ISO 4217 currency code is being used. Overriding the numeric formatting with information from the locale.");
584                                                         int digits = currency.getDefaultFractionDigits();
585                                                         numFormatJava = NumberFormat.getCurrencyInstance(locale);
586                                                         numFormatJava.setCurrency(currency);
587                                                         numFormatJava.setMinimumFractionDigits(digits);
588                                                         numFormatJava.setMaximumFractionDigits(digits);
589                                                 } catch (IllegalArgumentException e) {
590                                                         Log.warn(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle
591                                                                         + " - " + tableName + ": " + currencyCode
592                                                                         + " is not a valid ISO 4217 code. Manually setting currency code with this value.");
593                                                         // The currency code is not this is not an ISO 4217 currency code.
594                                                         // We're going to manually set the currency code and use the glom numeric formatting.
595                                                         useGlomCurrencyCode = true;
596                                                         numFormatJava = getJavaNumberFormat(numFormatGlom);
597                                                 }
598                                         } else if (currencyCode.length() > 0) {
599                                                 Log.warn(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle
600                                                                 + " - " + tableName + ": " + currencyCode
601                                                                 + " is not a valid ISO 4217 code. Manually setting currency code with this value.");
602                                                 // The length of the currency code is > 0 and != 3; this is not an ISO 4217 currency code.
603                                                 // We're going to manually set the currency code and use the glom numeric formatting.
604                                                 useGlomCurrencyCode = true;
605                                                 numFormatJava = getJavaNumberFormat(numFormatGlom);
606                                         } else {
607                                                 // The length of the currency code is 0; the number is not a currency.
608                                                 numFormatJava = getJavaNumberFormat(numFormatGlom);
609                                         }
610
611                                         // TODO: Do I need to do something with NumericFormat.get_default_precision() from libglom?
612
613                                         double number = rs.getDouble(i + 1);
614                                         if (number < 0) {
615                                                 if (formatting.getM_numeric_format().getM_alt_foreground_color_for_negatives())
616                                                         // overrides the set foreground colour
617                                                         rowArray[i].setFGColour(convertGdkColorToHtmlColour(NumericFormat
618                                                                         .get_alternative_color_for_negatives()));
619                                         }
620
621                                         // Finally convert the number to text using the glom currency string if required.
622                                         if (useGlomCurrencyCode) {
623                                                 rowArray[i].setText(currencyCode + " " + numFormatJava.format(number));
624                                         } else {
625                                                 rowArray[i].setText(numFormatJava.format(number));
626                                         }
627                                         break;
628                                 case TYPE_DATE:
629                                         Date date = rs.getDate(i + 1);
630                                         if (date != null) {
631                                                 DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.MEDIUM, locale);
632                                                 rowArray[i].setText(dateFormat.format(date));
633                                         } else {
634                                                 rowArray[i].setText("");
635                                         }
636                                         break;
637                                 case TYPE_TIME:
638                                         Time time = rs.getTime(i + 1);
639                                         if (time != null) {
640                                                 DateFormat timeFormat = DateFormat.getTimeInstance(DateFormat.MEDIUM, locale);
641                                                 rowArray[i].setText(timeFormat.format(time));
642                                         } else {
643                                                 rowArray[i].setText("");
644                                         }
645                                         break;
646                                 case TYPE_IMAGE:
647                                         byte[] image = rs.getBytes(i + 1);
648                                         if (image != null) {
649                                                 // TODO implement field TYPE_IMAGE
650                                                 rowArray[i].setText("Image (FIXME)");
651                                         } else {
652                                                 rowArray[i].setText("");
653                                         }
654                                         break;
655                                 case TYPE_INVALID:
656                                 default:
657                                         Log.warn(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
658                                                         + tableName + ": Invalid LayoutItem Field type. Using empty string for value.");
659                                         rowArray[i].setText("");
660                                         break;
661                                 }
662                         }
663
664                         // add the row of GlomFields to the ArrayList we're going to return and update the row count
665                         rowsList.add(rowArray);
666                         rowCount++;
667                 }
668
669                 return rowsList;
670         }
671
672         public ArrayList<String> getDocumentTitles() {
673                 ArrayList<String> documentTitles = new ArrayList<String>();
674                 for (String title : documents.keySet()) {
675                         documentTitles.add(title);
676                 }
677                 return documentTitles;
678         }
679
680         /*
681          * This method safely converts longs from libglom into ints. This method was taken from stackoverflow:
682          * 
683          * http://stackoverflow.com/questions/1590831/safely-casting-long-to-int-in-java
684          */
685         private int safeLongToInt(long value) {
686                 if (value < Integer.MIN_VALUE || value > Integer.MAX_VALUE) {
687                         throw new IllegalArgumentException(value + " cannot be cast to int without changing its value.");
688                 }
689                 return (int) value;
690         }
691
692         private NumberFormat getJavaNumberFormat(NumericFormat numFormatGlom) {
693                 NumberFormat numFormatJava = NumberFormat.getInstance(locale);
694                 if (numFormatGlom.getM_decimal_places_restricted()) {
695                         int digits = safeLongToInt(numFormatGlom.getM_decimal_places());
696                         numFormatJava.setMinimumFractionDigits(digits);
697                         numFormatJava.setMaximumFractionDigits(digits);
698                 }
699                 numFormatJava.setGroupingUsed(numFormatGlom.getM_use_thousands_separator());
700                 return numFormatJava;
701         }
702
703         /*
704          * Converts a Gdk::Color (16-bits per channel) to an HTML colour (8-bits per channel) by discarding the least
705          * significant 8-bits in each channel.
706          */
707         private String convertGdkColorToHtmlColour(String gdkColor) {
708                 if (gdkColor.length() == 13)
709                         return gdkColor.substring(0, 3) + gdkColor.substring(5, 7) + gdkColor.substring(9, 11);
710                 else if (gdkColor.length() == 7) {
711                         // This shouldn't happen but let's deal with it if it does.
712                         Log.warn(Thread.currentThread().getStackTrace()[1].getMethodName()
713                                         + ": Expected a 13 character string but received a 7 character string. Returning received string.");
714                         return gdkColor;
715                 } else {
716                         Log.error(Thread.currentThread().getStackTrace()[1].getMethodName()
717                                         + ": Did not receive a 13 or 7 character string. Returning black HTML colour code.");
718                         return "#000000";
719                 }
720         }
721
722         /*
723          * This method converts a FieldFormatting.HorizontalAlignment to the equivalent ColumnInfo.HorizontalAlignment. The
724          * need for this comes from the fact that the GWT HorizontalAlignment classes can't be used with RPC and there's no
725          * easy way to use the java-libglom FieldFormatting.HorizontalAlignment enum with RPC. An enum identical to
726          * FieldFormatting.HorizontalAlignment is included in the ColumnInfo class.
727          */
728         private ColumnInfo.HorizontalAlignment getColumnInfoHorizontalAlignment(
729                         FieldFormatting.HorizontalAlignment alignment) {
730                 switch (alignment) {
731                 case HORIZONTAL_ALIGNMENT_AUTO:
732                         return ColumnInfo.HorizontalAlignment.HORIZONTAL_ALIGNMENT_AUTO;
733                 case HORIZONTAL_ALIGNMENT_LEFT:
734                         return ColumnInfo.HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT;
735                 case HORIZONTAL_ALIGNMENT_RIGHT:
736                         return ColumnInfo.HorizontalAlignment.HORIZONTAL_ALIGNMENT_RIGHT;
737                 default:
738                         Log.error(Thread.currentThread().getStackTrace()[1].getMethodName()
739                                         + ": Recieved an alignment that I don't know about: "
740                                         + FieldFormatting.HorizontalAlignment.class.getName() + "." + alignment.toString() + ". Returning "
741                                         + ColumnInfo.HorizontalAlignment.HORIZONTAL_ALIGNMENT_RIGHT.toString() + ".");
742                         return ColumnInfo.HorizontalAlignment.HORIZONTAL_ALIGNMENT_RIGHT;
743                 }
744         }
745
746         /*
747          * This method converts a Field.glom_field_type to the equivalent ColumnInfo.FieldType. The need for this comes from
748          * the fact that the GWT FieldType classes can't be used with RPC and there's no easy way to use the java-libglom
749          * Field.glom_field_type enum with RPC. An enum identical to FieldFormatting.glom_field_type is included in the
750          * ColumnInfo class.
751          */
752         private ColumnInfo.GlomFieldType getColumnInfoGlomFieldType(Field.glom_field_type type) {
753                 switch (type) {
754                 case TYPE_BOOLEAN:
755                         return ColumnInfo.GlomFieldType.TYPE_BOOLEAN;
756                 case TYPE_DATE:
757                         return ColumnInfo.GlomFieldType.TYPE_DATE;
758                 case TYPE_IMAGE:
759                         return ColumnInfo.GlomFieldType.TYPE_IMAGE;
760                 case TYPE_NUMERIC:
761                         return ColumnInfo.GlomFieldType.TYPE_NUMERIC;
762                 case TYPE_TEXT:
763                         return ColumnInfo.GlomFieldType.TYPE_TEXT;
764                 case TYPE_TIME:
765                         return ColumnInfo.GlomFieldType.TYPE_TIME;
766                 case TYPE_INVALID:
767                         Log.info(Thread.currentThread().getStackTrace()[1].getMethodName() + ": Returning TYPE_INVALID.");
768                         return ColumnInfo.GlomFieldType.TYPE_INVALID;
769                 default:
770                         Log.error(Thread.currentThread().getStackTrace()[1].getMethodName()
771                                         + ": Recieved a type that I don't know about: " + Field.glom_field_type.class.getName() + "."
772                                         + type.toString() + ". Returning " + ColumnInfo.GlomFieldType.TYPE_INVALID.toString() + ".");
773                         return ColumnInfo.GlomFieldType.TYPE_INVALID;
774                 }
775         }
776
777         /*
778          * (non-Javadoc)
779          * 
780          * @see org.glom.web.client.OnlineGlomService#isAuthenticated(java.lang.String)
781          */
782         public boolean isAuthenticated(String documentTitle) {
783                 return documents.get(documentTitle).isAuthenticated();
784         }
785
786         /*
787          * (non-Javadoc)
788          * 
789          * @see org.glom.web.client.OnlineGlomService#checkAuthentication(java.lang.String, java.lang.String,
790          * java.lang.String)
791          */
792         public boolean checkAuthentication(String documentTitle, String username, String password) {
793                 ConfiguredDocument configuredDoc = documents.get(documentTitle);
794                 boolean authenticated;
795                 try {
796                         authenticated = checkAuthentication(documentTitle, configuredDoc.getCpds(), username, password);
797                 } catch (SQLException e) {
798                         Log.error(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle, e);
799                         return false;
800                 }
801                 configuredDoc.setAuthenticated(authenticated);
802                 return authenticated;
803         }
804
805         /*
806          * (non-Javadoc)
807          * 
808          * @see org.glom.web.client.OnlineGlomService#getDefaultDetailsLayoutGroup(java.lang.String)
809          */
810         @Override
811         public ArrayList<LayoutGroup> getDefaultDetailsLayout(String documentTitle) {
812                 GlomDocument glomDocument = getGlomDocument(documentTitle);
813                 String tableName = glomDocument.getTableNames().get(glomDocument.getDefaultTableIndex());
814                 return getDetailsLayout(documentTitle, tableName);
815         }
816
817         /*
818          * (non-Javadoc)
819          * 
820          * @see org.glom.web.client.OnlineGlomService#getDetailsLayoutGroup(java.lang.String, java.lang.String)
821          */
822         public ArrayList<LayoutGroup> getDetailsLayout(String documentTitle, String tableName) {
823                 // FIXME not checking if authenticated
824                 ConfiguredDocument configuredDoc = documents.get(documentTitle);
825                 Document document = configuredDoc.getDocument();
826                 LayoutGroupVector layoutGroupVec = document.get_data_layout_groups("details", tableName);
827
828                 ArrayList<LayoutGroup> layoutGroups = new ArrayList<LayoutGroup>();
829                 for (int i = 0; i < layoutGroupVec.size(); i++) {
830                         org.glom.libglom.LayoutGroup libglomLayoutGroup = layoutGroupVec.get(i);
831
832                         if (libglomLayoutGroup == null)
833                                 continue;
834
835                         layoutGroups.add(getLayoutGroup(documentTitle, tableName, libglomLayoutGroup));
836                 }
837                 return layoutGroups;
838         }
839
840         /**
841          * Gets a GWT-Glom LayoutGroup object for the specified libglom LayoutGroup object.
842          * 
843          * @param libglomLayoutGroup
844          *            <dt><b>Precondition:</b>
845          *            <dd>
846          *            libglomLayoutGroup must not be null
847          * @return
848          */
849         private LayoutGroup getLayoutGroup(String documentTitle, String tableName,
850                         org.glom.libglom.LayoutGroup libglomLayoutGroup) {
851                 LayoutGroup layoutGroup = new LayoutGroup();
852                 layoutGroup.setColumnCount(safeLongToInt(libglomLayoutGroup.get_columns_count()));
853
854                 // look at each child item
855                 LayoutItemVector layoutItemsVec = libglomLayoutGroup.get_items();
856                 for (int i = 0; i < layoutItemsVec.size(); i++) {
857                         org.glom.libglom.LayoutItem libglomLayoutItem = layoutItemsVec.get(i);
858
859                         // just a safety check
860                         if (libglomLayoutItem == null)
861                                 continue;
862
863                         org.glom.web.shared.layout.LayoutItem layoutItem = null;
864                         org.glom.libglom.LayoutGroup group = org.glom.libglom.LayoutGroup.cast_dynamic(libglomLayoutItem);
865                         if (group != null) {
866                                 // recurse into child groups
867                                 layoutItem = getLayoutGroup(documentTitle, tableName, group);
868                         } else {
869                                 // create GWT-Glom LayoutItem types based on the the libglom type
870                                 LayoutItem_Field tempField = LayoutItem_Field.cast_dynamic(libglomLayoutItem);
871                                 if (tempField != null) {
872                                         layoutItem = new LayoutItemField();
873                                 } else {
874                                         Log.info(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
875                                                         + tableName + ": Ignoring unknown LayoutItem of type "
876                                                         + libglomLayoutItem.get_part_type_name() + ".");
877                                         continue;
878                                 }
879                         }
880
881                         layoutItem.setTitle(libglomLayoutItem.get_title_or_name());
882                         layoutGroup.addItem(layoutItem);
883                 }
884
885                 return layoutGroup;
886         }
887
888         public GlomField[] getDetailsData(String documentTitle, String tableName, String primaryKeyValue) {
889
890                 ConfiguredDocument configuredDoc = documents.get(documentTitle);
891                 Document document = configuredDoc.getDocument();
892
893                 LayoutFieldVector fieldsToGet = getFieldsToShowForSQLQuery(document, tableName);
894
895                 if (fieldsToGet == null || fieldsToGet.size() <= 0) {
896                         Log.warn(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
897                                         + tableName + ": Didn't find any fields to show. Returning null.");
898                         return null;
899                 }
900
901                 // get primary key for the table to use in the SQL query
902                 Field primaryKey = null;
903                 FieldVector fieldsVec = document.get_table_fields(tableName);
904                 for (int i = 0; i < safeLongToInt(fieldsVec.size()); i++) {
905                         Field field = fieldsVec.get(i);
906                         if (field.get_primary_key()) {
907                                 primaryKey = field;
908                                 break;
909                         }
910                 }
911
912                 // send back an empty GlomField array if can't find a primaryKey Field
913                 if (primaryKey == null) {
914                         Log.error(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
915                                         + tableName + ": Couldn't find primary key in table. Returning null.");
916                         return null;
917                 }
918
919                 ArrayList<GlomField[]> rowsList = new ArrayList<GlomField[]>();
920                 Connection conn = null;
921                 Statement st = null;
922                 ResultSet rs = null;
923                 try {
924                         // Setup the JDBC driver and get the query.
925                         ComboPooledDataSource cpds = configuredDoc.getCpds();
926                         conn = cpds.getConnection();
927                         st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
928                         String query = Glom.build_sql_select_with_key(tableName, fieldsToGet, primaryKey, primaryKeyValue);
929                         rs = st.executeQuery(query);
930
931                         // get the results from the ResultSet
932                         // using 2 as a length parameter so we can log a warning if the result set is greater than one
933                         rowsList = getData(documentTitle, tableName, 2, fieldsToGet, rs);
934                 } catch (SQLException e) {
935                         Log.error(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
936                                         + tableName + ": Error executing database query.", e);
937                         // TODO: somehow notify user of problem
938                         return null;
939                 } finally {
940                         // cleanup everything that has been used
941                         try {
942                                 if (rs != null)
943                                         rs.close();
944                                 if (st != null)
945                                         st.close();
946                                 if (conn != null)
947                                         conn.close();
948                         } catch (Exception e) {
949                                 Log.error(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
950                                                 + tableName + ": Error closing database resources. Subsequent database queries may not work.",
951                                                 e);
952                         }
953                 }
954
955                 if (rowsList.size() == 0) {
956                         Log.error(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
957                                         + tableName + ": The query returned an empty ResultSet. Returning null.");
958                         return null;
959                 } else if (rowsList.size() > 1) {
960                         Log.warn(Thread.currentThread().getStackTrace()[1].getMethodName() + ": " + documentTitle + " - "
961                                         + tableName + ": The query did not return a unique result. Returning the first result in the set.");
962                 }
963
964                 return rowsList.get(0);
965
966         }
967
968         /*
969          * Gets a LayoutFieldVector to use when generating an SQL query.
970          */
971         private LayoutFieldVector getFieldsToShowForSQLQuery(Document document, String tableName) {
972                 // TODO make general to be able to use "list" here - will need to change called methods
973                 LayoutGroupVector layoutGroupVec = document.get_data_layout_groups("details", tableName);
974
975                 // We will show the fields that the document says we should:
976                 LayoutFieldVector layoutFieldVector = new LayoutFieldVector();
977                 for (int i = 0; i < layoutGroupVec.size(); i++) {
978                         org.glom.libglom.LayoutGroup layoutGroup = layoutGroupVec.get(i);
979
980                         // Get the fields:
981                         ArrayList<LayoutItem_Field> layoutItemsFields = getFieldsToShowForSQLQueryAddGroup(document,
982                                         tableName, layoutGroup);
983                         for (LayoutItem_Field layoutItem_Field : layoutItemsFields) {
984                                 layoutFieldVector.add(layoutItem_Field);
985                         }
986                 }
987                 return layoutFieldVector;
988         }
989
990         private ArrayList<LayoutItem_Field> getFieldsToShowForSQLQueryAddGroup(Document document, String tableName,
991                         org.glom.libglom.LayoutGroup layoutGroup) {
992
993                 ArrayList<LayoutItem_Field> layoutItemFields = new ArrayList<LayoutItem_Field>();
994                 LayoutItemVector items = layoutGroup.get_items();
995                 for (int i = 0; i < items.size(); i++) {
996                         LayoutItem layoutItem = items.get(i);
997
998                         LayoutItem_Field layoutItemField = LayoutItem_Field.cast_dynamic(layoutItem);
999                         if (layoutItemField != null) {
1000                                 // the layoutItem is a LayoutItem_Field
1001                                 FieldVector fields;
1002                                 if (layoutItemField.get_has_relationship_name()) {
1003                                         // layoutItemField is a field in a related table
1004                                         fields = document.get_table_fields(layoutItemField.get_table_used(tableName));
1005                                 } else {
1006                                         // layoutItemField is a field in this table
1007                                         fields = document.get_table_fields(tableName);
1008                                 }
1009
1010                                 // set the layoutItemFeild with details from its Field in the document and
1011                                 // add it to the list to be returned
1012                                 for (int j = 0; j < fields.size(); j++) {
1013                                         // check the names to see if they're the same
1014                                         // this works because we're using the field list from the related table if necessary
1015                                         if (layoutItemField.get_name().equals(fields.get(j).get_name())) {
1016                                                 Field field = fields.get(j);
1017                                                 if (field != null) {
1018                                                         layoutItemField.set_full_field_details(field);
1019                                                         layoutItemFields.add(layoutItemField);
1020                                                 } else {
1021                                                         Log.warn(Thread.currentThread().getStackTrace()[1].getMethodName() + ": "
1022                                                                         + document.get_database_title() + " - " + tableName + "LayoutItem_Field "
1023                                                                         + layoutItemField.get_layout_display_name() + "not found in document field list.");
1024                                                 }
1025                                                 break;
1026                                         }
1027                                 }
1028
1029                         } else {
1030                                 // the layoutItem is not a LayoutItem_Field
1031                                 org.glom.libglom.LayoutGroup subLayoutGroup = org.glom.libglom.LayoutGroup.cast_dynamic(layoutItem);
1032                                 if (subLayoutGroup != null) {
1033                                         // the layoutItem is a LayoutGroup
1034                                         LayoutItem_Portal layoutItemPortal = LayoutItem_Portal.cast_dynamic(layoutItem);
1035                                         if (layoutItemPortal == null) {
1036                                                 // The subGroup is not a LayoutItem_Portal.
1037                                                 // We're ignoring portals because they are filled by means of a separate SQL query.
1038                                                 layoutItemFields.addAll(getFieldsToShowForSQLQueryAddGroup(document, tableName,
1039                                                                 subLayoutGroup));
1040                                         }
1041                                 }
1042                         }
1043                 }
1044                 return layoutItemFields;
1045         }
1046
1047 }