Some final keywords, by Eclipse
[online-glom:gwt-glom.git] / src / main / java / org / glom / web / server / ConfiguredDocument.java
1 /*
2  * Copyright (C) 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.sql.Connection;
24 import java.sql.SQLException;
25 import java.util.ArrayList;
26 import java.util.Hashtable;
27 import java.util.List;
28 import java.util.Locale;
29
30 import org.apache.commons.lang3.StringUtils;
31 import org.glom.web.server.database.DetailsDBAccess;
32 import org.glom.web.server.database.ListViewDBAccess;
33 import org.glom.web.server.database.RelatedListDBAccess;
34 import org.glom.web.server.database.RelatedListNavigation;
35 import org.glom.web.server.libglom.Document;
36 import org.glom.web.shared.DataItem;
37 import org.glom.web.shared.DocumentInfo;
38 import org.glom.web.shared.NavigationRecord;
39 import org.glom.web.shared.Reports;
40 import org.glom.web.shared.TypedDataItem;
41 import org.glom.web.shared.libglom.CustomTitle;
42 import org.glom.web.shared.libglom.Field;
43 import org.glom.web.shared.libglom.Relationship;
44 import org.glom.web.shared.libglom.Report;
45 import org.glom.web.shared.libglom.Translatable;
46 import org.glom.web.shared.libglom.layout.LayoutGroup;
47 import org.glom.web.shared.libglom.layout.LayoutItem;
48 import org.glom.web.shared.libglom.layout.LayoutItemField;
49 import org.glom.web.shared.libglom.layout.LayoutItemPortal;
50 import org.glom.web.shared.libglom.layout.TableToViewDetails;
51 import org.glom.web.shared.libglom.layout.UsesRelationship;
52
53 import com.mchange.v2.c3p0.ComboPooledDataSource;
54
55 /**
56  * A class to hold configuration information for a given Glom document. This class retrieves layout information from
57  * libglom and data from the underlying PostgreSQL database.
58  */
59 final class ConfiguredDocument {
60
61         private Document document;
62         private ComboPooledDataSource cpds;
63         private boolean authenticated = false;
64         private String documentID = "";
65         private String defaultLocaleID = "";
66
67         private static class LayoutLocaleMap extends Hashtable<String, List<LayoutGroup>> {
68                 private static final long serialVersionUID = 6542501521673767267L;
69         };
70
71         private static class TableLayouts {
72                 public LayoutLocaleMap listLayouts;
73                 public LayoutLocaleMap detailsLayouts;
74         }
75
76         private static class TableLayoutsForLocale extends Hashtable<String, TableLayouts> {
77                 private static final long serialVersionUID = -1947929931925049013L;
78
79                 public LayoutGroup getListLayout(final String tableName, final String locale) {
80                         final List<LayoutGroup> groups = getLayout(tableName, locale, false);
81                         if (groups == null) {
82                                 return null;
83                         }
84
85                         if (groups.isEmpty()) {
86                                 return null;
87                         }
88
89                         return groups.get(0);
90                 }
91
92                 public List<LayoutGroup> getDetailsLayout(final String tableName, final String locale) {
93                         return getLayout(tableName, locale, true);
94                 }
95
96                 public void setListLayout(final String tableName, final String locale, final LayoutGroup layout) {
97                         final List<LayoutGroup> list = new ArrayList<LayoutGroup>();
98                         list.add(layout);
99                         setLayout(tableName, locale, list, false);
100                 }
101
102                 public void setDetailsLayout(final String tableName, final String locale, final List<LayoutGroup> layout) {
103                         setLayout(tableName, locale, layout, true);
104                 }
105
106                 private List<LayoutGroup> getLayout(final String tableName, final String locale, final boolean details) {
107                         final LayoutLocaleMap map = getMap(tableName, details);
108
109                         if (map == null) {
110                                 return null;
111                         }
112
113                         return map.get(locale);
114                 }
115
116                 private LayoutLocaleMap getMap(final String tableName, final boolean details) {
117                         final TableLayouts tableLayouts = get(tableName);
118                         if (tableLayouts == null) {
119                                 return null;
120                         }
121
122                         LayoutLocaleMap map = null;
123                         if (details) {
124                                 map = tableLayouts.detailsLayouts;
125                         } else {
126                                 map = tableLayouts.listLayouts;
127                         }
128
129                         return map;
130                 }
131
132                 private LayoutLocaleMap getMapWithAdd(final String tableName, final boolean details) {
133                         TableLayouts tableLayouts = get(tableName);
134                         if (tableLayouts == null) {
135                                 tableLayouts = new TableLayouts();
136                                 put(tableName, tableLayouts);
137                         }
138
139                         LayoutLocaleMap map = null;
140                         if (details) {
141                                 if (tableLayouts.detailsLayouts == null) {
142                                         tableLayouts.detailsLayouts = new LayoutLocaleMap();
143                                 }
144
145                                 map = tableLayouts.detailsLayouts;
146                         } else {
147                                 if (tableLayouts.listLayouts == null) {
148                                         tableLayouts.listLayouts = new LayoutLocaleMap();
149                                 }
150
151                                 map = tableLayouts.listLayouts;
152                         }
153
154                         return map;
155                 }
156
157                 private void setLayout(final String tableName, final String locale, final List<LayoutGroup> layout,
158                                 final boolean details) {
159                         final LayoutLocaleMap map = getMapWithAdd(tableName, details);
160                         if (map != null) {
161                                 map.put(locale, layout);
162                         }
163                 }
164         }
165
166         private final TableLayoutsForLocale mapTableLayouts = new TableLayoutsForLocale();
167
168         @SuppressWarnings("unused")
169         private ConfiguredDocument() {
170                 // disable default constructor
171         }
172
173         ConfiguredDocument(final Document document) throws PropertyVetoException {
174
175                 // load the jdbc driver
176                 cpds = createAndSetupDataSource(document);
177
178                 this.document = document;
179         }
180
181         /**
182          * @param document
183          * @return
184          */
185         private static ComboPooledDataSource createAndSetupDataSource(final Document document) {
186                 final ComboPooledDataSource cpds = new ComboPooledDataSource();
187
188                 // We don't support sqlite or self-hosting yet.
189                 if ((document.getHostingMode() != Document.HostingMode.HOSTING_MODE_POSTGRES_CENTRAL)
190                                 && (document.getHostingMode() != Document.HostingMode.HOSTING_MODE_POSTGRES_SELF)) {
191                         // TODO: We allow self-hosting here, for testing,
192                         // but maybe the startup of self-hosting should happen here.
193                         Log.fatal("Error configuring the database connection." + " Only PostgreSQL hosting is supported.");
194                         // FIXME: Throw exception?
195                 }
196
197                 try {
198                         cpds.setDriverClass("org.postgresql.Driver");
199                 } catch (final PropertyVetoException e) {
200                         Log.fatal("Error loading the PostgreSQL JDBC driver."
201                                         + " Is the PostgreSQL JDBC jar available to the servlet?", e);
202                         return null;
203                 }
204
205                 // setup the JDBC driver for the current glom document
206                 String jdbcURL = "jdbc:postgresql://" + document.getConnectionServer() + ":" + document.getConnectionPort();
207
208                 String db = document.getConnectionDatabase();
209                 if (StringUtils.isEmpty(db)) {
210                         // Use the default PostgreSQL database, because ComboPooledDataSource.connect() fails otherwise.
211                         db = "template1";
212                 }
213                 jdbcURL += "/" + db; // TODO: Quote the database name?
214
215                 cpds.setJdbcUrl(jdbcURL);
216
217                 return cpds;
218         }
219
220         /**
221          * Sets the username and password for the database associated with the Glom document.
222          * 
223          * @return true if the username and password works, false otherwise
224          */
225         boolean setUsernameAndPassword(final String username, final String password) throws SQLException {
226                 cpds.setUser(username);
227                 cpds.setPassword(password);
228
229                 final int acquireRetryAttempts = cpds.getAcquireRetryAttempts();
230                 cpds.setAcquireRetryAttempts(1);
231                 Connection conn = null;
232                 try {
233                         // FIXME find a better way to check authentication
234                         // it's possible that the connection could be failing for another reason
235                         conn = cpds.getConnection();
236                         authenticated = true;
237                 } catch (final SQLException e) {
238                         Log.info(Utils.getFileName(document.getFileURI()), e.getMessage());
239                         Log.info(Utils.getFileName(document.getFileURI()),
240                                         "Connection Failed. Maybe the username or password is not correct.");
241                         authenticated = false;
242                 } finally {
243                         if (conn != null) {
244                                 conn.close();
245                         }
246                         cpds.setAcquireRetryAttempts(acquireRetryAttempts);
247                 }
248                 return authenticated;
249         }
250
251         Document getDocument() {
252                 return document;
253         }
254
255         ComboPooledDataSource getCpds() {
256                 return cpds;
257         }
258
259         boolean isAuthenticated() {
260                 return authenticated;
261         }
262
263         String getDocumentID() {
264                 return documentID;
265         }
266
267         void setDocumentID(final String documentID) {
268                 this.documentID = documentID;
269         }
270
271         String getDefaultLocaleID() {
272                 return defaultLocaleID;
273         }
274
275         void setDefaultLocaleID(final String localeID) {
276                 this.defaultLocaleID = localeID;
277         }
278
279         /**
280          * @return
281          */
282         DocumentInfo getDocumentInfo(final String localeID) {
283                 final DocumentInfo documentInfo = new DocumentInfo();
284
285                 // get arrays of table names and titles, and find the default table index
286                 final List<String> tablesVec = document.getTableNames();
287
288                 final int numTables = Utils.safeLongToInt(tablesVec.size());
289                 // we don't know how many tables will be hidden so we'll use half of the number of tables for the default size
290                 // of the ArrayList
291                 final ArrayList<String> tableNames = new ArrayList<String>(numTables / 2);
292                 final ArrayList<String> tableTitles = new ArrayList<String>(numTables / 2);
293                 boolean foundDefaultTable = false;
294                 int visibleIndex = 0;
295                 for (int i = 0; i < numTables; i++) {
296                         final String tableName = tablesVec.get(i);
297                         if (!document.getTableIsHidden(tableName)) {
298                                 tableNames.add(tableName);
299                                 // JNI is "expensive", the comparison will only be called if we haven't already found the default table
300                                 if (!foundDefaultTable && tableName.equals(document.getDefaultTable())) {
301                                         documentInfo.setDefaultTableIndex(visibleIndex);
302                                         foundDefaultTable = true;
303                                 }
304                                 tableTitles.add(document.getTableTitle(tableName, localeID));
305                                 visibleIndex++;
306                         }
307                 }
308
309                 // set everything we need
310                 documentInfo.setTableNames(tableNames);
311                 documentInfo.setTableTitles(tableTitles);
312                 documentInfo.setTitle(document.getDatabaseTitle(localeID));
313
314                 // Fetch arrays of locale IDs and titles:
315                 final List<String> localesVec = document.getTranslationAvailableLocales();
316                 final int numLocales = Utils.safeLongToInt(localesVec.size());
317                 final ArrayList<String> localeIDs = new ArrayList<String>(numLocales);
318                 final ArrayList<String> localeTitles = new ArrayList<String>(numLocales);
319                 for (int i = 0; i < numLocales; i++) {
320                         final String this_localeID = localesVec.get(i);
321                         localeIDs.add(this_localeID);
322
323                         // Use java.util.Locale to get a title for the locale:
324                         final String[] locale_parts = this_localeID.split("_");
325                         String locale_lang = this_localeID;
326                         if (locale_parts.length > 0) {
327                                 locale_lang = locale_parts[0];
328                         }
329                         String locale_country = "";
330                         if (locale_parts.length > 1) {
331                                 locale_country = locale_parts[1];
332                         }
333
334                         final Locale locale = new Locale(locale_lang, locale_country);
335                         final String title = locale.getDisplayName(locale);
336                         localeTitles.add(title);
337                 }
338                 documentInfo.setLocaleIDs(localeIDs);
339                 documentInfo.setLocaleTitles(localeTitles);
340
341                 return documentInfo;
342         }
343
344         /*
345          * Gets the layout group for the list view using the defined layout list in the document or the table fields if
346          * there's no defined layout group for the list view.
347          */
348         private LayoutGroup getValidListViewLayoutGroup(final String tableName, final String localeID) {
349
350                 // Try to return a cached version:
351                 final LayoutGroup result = mapTableLayouts.getListLayout(tableName, localeID);
352                 if (result != null) {
353                         updateLayoutGroupExpectedResultSize(result, tableName);
354                         return result;
355                 }
356
357                 final List<LayoutGroup> layoutGroupVec = document.getDataLayoutGroups("list", tableName);
358
359                 final int listViewLayoutGroupSize = Utils.safeLongToInt(layoutGroupVec.size());
360                 LayoutGroup libglomLayoutGroup = null;
361                 if (listViewLayoutGroupSize > 0) {
362                         // A list layout group is defined.
363                         // We use the first group as the list.
364                         if (listViewLayoutGroupSize > 1) {
365                                 Log.warn(documentID, tableName, "The size of the list layout group is greater than 1. "
366                                                 + "Attempting to use the first item for the layout list view.");
367                         }
368
369                         libglomLayoutGroup = layoutGroupVec.get(0);
370                 } else {
371                         // A list layout group is *not* defined; we are going make a LayoutGroup from the list of fields.
372                         // This is unusual.
373                         Log.info(documentID, tableName,
374                                         "A list layout is not defined for this table. Displaying a list layout based on the field list.");
375
376                         final List<Field> fieldsVec = document.getTableFields(tableName);
377                         libglomLayoutGroup = new LayoutGroup();
378                         for (int i = 0; i < fieldsVec.size(); i++) {
379                                 final Field field = fieldsVec.get(i);
380                                 final LayoutItemField layoutItemField = new LayoutItemField();
381                                 layoutItemField.setFullFieldDetails(field);
382                                 libglomLayoutGroup.addItem(layoutItemField);
383                         }
384                 }
385
386                 // TODO: Clone the group and change the clone, to discard unwanted information (such as translations)
387                 // store some information that we do not want to calculate on the client side.
388
389                 // Note that we don't use clone() here, because that would need clone() implementations
390                 // in classes which are also used in the client code (though the clone() methods would
391                 // not be used) and that makes the GWT java->javascript compilation fail.
392                 final LayoutGroup cloned = (LayoutGroup) Utils.deepCopy(libglomLayoutGroup);
393                 if (cloned != null) {
394                         updateTopLevelListLayoutGroup(cloned, tableName, localeID);
395
396                         // Discard unwanted translations so that getTitle(void) returns what we want.
397                         updateTitlesForLocale(cloned, localeID);
398                 }
399
400                 // Store it in the cache for next time.
401                 mapTableLayouts.setListLayout(tableName, localeID, cloned);
402
403                 return cloned;
404         }
405
406         /**
407          * @param libglomLayoutGroup
408          */
409         private void updateTopLevelListLayoutGroup(final LayoutGroup layoutGroup, final String tableName,
410                         final String localeID) {
411                 final List<LayoutItem> layoutItemsVec = layoutGroup.getItems();
412
413                 int primaryKeyIndex = -1;
414
415                 final int numItems = Utils.safeLongToInt(layoutItemsVec.size());
416                 for (int i = 0; i < numItems; i++) {
417                         final LayoutItem layoutItem = layoutItemsVec.get(i);
418
419                         if (layoutItem instanceof LayoutItemField) {
420                                 final LayoutItemField layoutItemField = (LayoutItemField) layoutItem;
421                                 final Field field = layoutItemField.getFullFieldDetails();
422                                 if ((field != null) && field.getPrimaryKey()) {
423                                         primaryKeyIndex = i;
424                                 }
425                         }
426                 }
427
428                 // Set the primary key index for the table
429                 if (primaryKeyIndex < 0) {
430                         // Add a LayoutItemField for the primary key to the end of the item list in the LayoutGroup because it
431                         // doesn't already contain a primary key.
432                         Field primaryKey = null;
433                         final List<Field> fieldsVec = document.getTableFields(tableName);
434                         for (int i = 0; i < Utils.safeLongToInt(fieldsVec.size()); i++) {
435                                 final Field field = fieldsVec.get(i);
436                                 if (field.getPrimaryKey()) {
437                                         primaryKey = field;
438                                         break;
439                                 }
440                         }
441
442                         if (primaryKey != null) {
443                                 final LayoutItemField layoutItemField = new LayoutItemField();
444                                 layoutItemField.setName(primaryKey.getName());
445                                 layoutItemField.setFullFieldDetails(primaryKey);
446                                 layoutGroup.addItem(layoutItemField);
447                                 layoutGroup.setPrimaryKeyIndex(layoutGroup.getItems().size() - 1);
448                                 layoutGroup.setHiddenPrimaryKey(true);
449                         } else {
450                                 Log.error(document.getDatabaseTitleOriginal(), tableName,
451                                                 "A primary key was not found in the FieldVector for this table. Navigation buttons will not work.");
452                         }
453                 } else {
454                         layoutGroup.setPrimaryKeyIndex(primaryKeyIndex);
455                 }
456         }
457
458         private void updateLayoutGroupExpectedResultSize(final LayoutGroup layoutGroup, final String tableName) {
459                 final ListViewDBAccess listViewDBAccess = new ListViewDBAccess(document, documentID, cpds, tableName,
460                                 layoutGroup);
461                 layoutGroup.setExpectedResultSize(listViewDBAccess.getExpectedResultSize());
462         }
463
464         /**
465          * 
466          * @param tableName
467          * @param quickFind
468          * @param start
469          * @param length
470          * @param useSortClause
471          * @param sortColumnIndex
472          *            The index of the column to sort by, or -1 for none.
473          * @param isAscending
474          * @return
475          */
476         ArrayList<DataItem[]> getListViewData(String tableName, final String quickFind, final int start, final int length,
477                         final boolean useSortClause, final int sortColumnIndex, final boolean isAscending) {
478                 // Validate the table name.
479                 tableName = getTableNameToUse(tableName);
480
481                 // Get the LayoutGroup that represents the list view.
482                 // TODO: Performance: Avoid calling this again:
483                 final LayoutGroup libglomLayoutGroup = getValidListViewLayoutGroup(tableName, "" /* irrelevant locale */);
484
485                 // Create a database access object for the list view.
486                 final ListViewDBAccess listViewDBAccess = new ListViewDBAccess(document, documentID, cpds, tableName,
487                                 libglomLayoutGroup);
488
489                 // Return the data.
490                 return listViewDBAccess.getData(quickFind, start, length, sortColumnIndex, isAscending);
491         }
492
493         DataItem[] getDetailsData(String tableName, final TypedDataItem primaryKeyValue) {
494                 // Validate the table name.
495                 tableName = getTableNameToUse(tableName);
496
497                 final DetailsDBAccess detailsDBAccess = new DetailsDBAccess(document, documentID, cpds, tableName);
498
499                 return detailsDBAccess.getData(primaryKeyValue);
500         }
501
502         /**
503          * 
504          * @param tableName
505          * @param portal
506          * @param foreignKeyValue
507          * @param start
508          * @param length
509          * @param sortColumnIndex
510          *            The index of the column to sort by, or -1 for none.
511          * @param isAscending
512          * @return
513          */
514         ArrayList<DataItem[]> getRelatedListData(String tableName, final LayoutItemPortal portal,
515                         final TypedDataItem foreignKeyValue, final int start, final int length, final int sortColumnIndex,
516                         final boolean isAscending) {
517                 if (portal == null) {
518                         Log.error("getRelatedListData(): portal is null");
519                         return null;
520                 }
521
522                 // Validate the table name.
523                 tableName = getTableNameToUse(tableName);
524
525                 // Create a database access object for the related list
526                 final RelatedListDBAccess relatedListDBAccess = new RelatedListDBAccess(document, documentID, cpds, tableName,
527                                 portal);
528
529                 // Return the data
530                 return relatedListDBAccess.getData(start, length, foreignKeyValue, sortColumnIndex, isAscending);
531         }
532
533         List<LayoutGroup> getDetailsLayoutGroup(String tableName, final String localeID) {
534                 // Validate the table name.
535                 tableName = getTableNameToUse(tableName);
536
537                 // Try to return a cached version:
538                 final List<LayoutGroup> result = mapTableLayouts.getDetailsLayout(tableName, localeID);
539                 if (result != null) {
540                         updatePortalsExtras(result, tableName); // Update expected results sizes.
541                         return result;
542                 }
543
544                 final List<LayoutGroup> listGroups = document.getDataLayoutGroups("details", tableName);
545
546                 // Clone the group and change the clone, to discard unwanted information (such as translations)
547                 // and to store some information that we do not want to calculate on the client side.
548
549                 // Note that we don't use clone() here, because that would need clone() implementations
550                 // in classes which are also used in the client code (though the clone() methods would
551                 // not be used) and that makes the GWT java->javascript compilation fail.
552                 final List<LayoutGroup> listCloned = new ArrayList<LayoutGroup>();
553                 for (final LayoutGroup group : listGroups) {
554                         final LayoutGroup cloned = (LayoutGroup) Utils.deepCopy(group);
555                         if (cloned != null) {
556                                 listCloned.add(cloned);
557                         }
558                 }
559
560                 updatePortalsExtras(listCloned, tableName);
561                 updateFieldsExtras(listCloned, tableName);
562
563                 // Discard unwanted translations so that getTitle(void) returns what we want.
564                 updateTitlesForLocale(listCloned, localeID);
565
566                 // Store it in the cache for next time.
567                 mapTableLayouts.setDetailsLayout(tableName, localeID, listCloned);
568
569                 return listCloned;
570         }
571
572         /**
573          * @param result
574          * @param tableName
575          */
576         private void updatePortalsExtras(final List<LayoutGroup> listGroups, final String tableName) {
577                 for (final LayoutGroup group : listGroups) {
578                         updatePortalsExtras(group, tableName);
579                 }
580
581         }
582
583         /**
584          * @param result
585          * @param tableName
586          */
587         private void updateFieldsExtras(final List<LayoutGroup> listGroups, final String tableName) {
588                 for (final LayoutGroup group : listGroups) {
589                         updateFieldsExtras(group, tableName);
590                 }
591         }
592
593         /**
594          * @param result
595          * @param tableName
596          */
597         private void updateTitlesForLocale(final List<LayoutGroup> listGroups, final String localeID) {
598                 for (final LayoutGroup group : listGroups) {
599                         updateTitlesForLocale(group, localeID);
600                 }
601         }
602
603         private void updatePortalsExtras(final LayoutGroup group, final String tableName) {
604                 if (group instanceof LayoutItemPortal) {
605                         final LayoutItemPortal portal = (LayoutItemPortal) group;
606                         final String tableNameUsed = portal.getTableUsed(tableName);
607                         updateLayoutGroupExpectedResultSize(portal, tableNameUsed);
608
609                         final Relationship relationship = portal.getRelationship();
610                         if (relationship != null) {
611
612                                 // Cache the navigation information:
613                                 // layoutItemPortal.set_name(libglomLayoutItemPortal.get_relationship_name_used());
614                                 // layoutItemPortal.setTableName(relationship.get_from_table());
615                                 // layoutItemPortal.setFromField(relationship.get_from_field());
616
617                                 // Set whether the related list will need to show the navigation buttons,
618                                 // (null table name string if not) and what table to navigation to.
619                                 // This was ported from Glom: Box_Data_Portal::get_has_suitable_record_to_view_details()
620                                 final TableToViewDetails viewDetails = document.getPortalSuitableTableToViewDetails(portal);
621                                 if (viewDetails != null) {
622                                         portal.setNavigationTable(viewDetails);
623                                 }
624
625                                 // get the primary key for the related list table
626                                 final String toTableName = relationship.getToTable();
627                                 if (!StringUtils.isEmpty(toTableName)) {
628
629                                         // get the LayoutItemField with details from its Field in the document
630                                         final List<Field> fields = document.getTableFields(toTableName); // TODO_Performance: Cache this.
631                                         for (final Field field : fields) {
632                                                 // check the names to see if they're the same
633                                                 if (field.getPrimaryKey()) {
634                                                         final LayoutItemField layoutItemField = new LayoutItemField();
635                                                         layoutItemField.setName(field.getName());
636                                                         layoutItemField.setFullFieldDetails(field);
637                                                         portal.addItem(layoutItemField);
638                                                         portal.setPrimaryKeyIndex(portal.getItems().size() - 1);
639                                                         portal.setHiddenPrimaryKey(true); // always hidden in portals
640                                                         break;
641                                                 }
642                                         }
643                                 }
644                         }
645
646                 }
647
648                 final List<LayoutItem> childItems = group.getItems();
649                 for (final LayoutItem item : childItems) {
650                         if (item instanceof LayoutGroup) {
651                                 final LayoutGroup childGroup = (LayoutGroup) item;
652                                 updatePortalsExtras(childGroup, tableName);
653                         }
654                 }
655
656         }
657
658         private void updateFieldsExtras(final LayoutGroup group, final String tableName) {
659
660                 final List<LayoutItem> childItems = group.getItems();
661                 for (final LayoutItem item : childItems) {
662                         if (item instanceof LayoutGroup) {
663                                 // Recurse:
664                                 final LayoutGroup childGroup = (LayoutGroup) item;
665                                 updateFieldsExtras(childGroup, tableName);
666                         } else if (item instanceof LayoutItemField) {
667                                 final LayoutItemField field = (LayoutItemField) item;
668
669                                 // Set whether the field should have a navigation button,
670                                 // because it identifies a related record.
671                                 final String navigationTableName = document.getLayoutItemFieldShouldHaveNavigation(tableName, field);
672                                 if (navigationTableName != null) {
673                                         field.setNavigationTableName(navigationTableName);
674                                 }
675                         }
676                 }
677         }
678
679         private void updateTitlesForLocale(final LayoutGroup group, final String localeID) {
680
681                 updateItemTitlesForLocale(group, localeID);
682
683                 final List<LayoutItem> childItems = group.getItems();
684                 for (final LayoutItem item : childItems) {
685
686                         // Call makeTitleOriginal on all Translatable items and all special
687                         // Translatable items that they use:
688                         if (item instanceof LayoutItemField) {
689                                 final LayoutItemField layoutItemField = (LayoutItemField) item;
690
691                                 final Field field = layoutItemField.getFullFieldDetails();
692                                 if (field != null) {
693                                         field.makeTitleOriginal(localeID);
694                                 }
695
696                                 final CustomTitle customTitle = layoutItemField.getCustomTitle();
697                                 if (customTitle != null) {
698                                         customTitle.makeTitleOriginal(localeID);
699                                 }
700                         }
701
702                         updateItemTitlesForLocale(item, localeID);
703
704                         if (item instanceof LayoutGroup) {
705                                 // Recurse:
706                                 final LayoutGroup childGroup = (LayoutGroup) item;
707                                 updateTitlesForLocale(childGroup, localeID);
708                         }
709                 }
710         }
711
712         private void updateItemTitlesForLocale(final LayoutItem item, final String localeID) {
713                 if (item instanceof UsesRelationship) {
714                         final UsesRelationship usesRelationship = (UsesRelationship) item;
715                         final Relationship rel = usesRelationship.getRelationship();
716
717                         if (rel != null) {
718                                 rel.makeTitleOriginal(localeID);
719                         }
720
721                         final Relationship relatedRel = usesRelationship.getRelatedRelationship();
722                         if (relatedRel != null) {
723                                 relatedRel.makeTitleOriginal(localeID);
724                         }
725                 }
726
727                 if (item instanceof Translatable) {
728                         final Translatable translatable = item;
729                         translatable.makeTitleOriginal(localeID);
730                 }
731         }
732
733         /*
734          * Gets the expected row count for a related list.
735          */
736         int getRelatedListRowCount(String tableName, final LayoutItemPortal portal, final TypedDataItem foreignKeyValue) {
737                 if (portal == null) {
738                         Log.error("getRelatedListData(): portal is null");
739                         return 0;
740                 }
741
742                 // Validate the table name.
743                 tableName = getTableNameToUse(tableName);
744
745                 // Create a database access object for the related list
746                 final RelatedListDBAccess relatedListDBAccess = new RelatedListDBAccess(document, documentID, cpds, tableName,
747                                 portal);
748
749                 // Return the row count
750                 return relatedListDBAccess.getExpectedResultSize(foreignKeyValue);
751         }
752
753         NavigationRecord getSuitableRecordToViewDetails(String tableName, final LayoutItemPortal portal,
754                         final TypedDataItem primaryKeyValue) {
755                 // Validate the table name.
756                 tableName = getTableNameToUse(tableName);
757
758                 final RelatedListNavigation relatedListNavigation = new RelatedListNavigation(document, documentID, cpds,
759                                 tableName, portal);
760
761                 return relatedListNavigation.getNavigationRecord(primaryKeyValue);
762         }
763
764         LayoutGroup getListViewLayoutGroup(String tableName, final String localeID) {
765                 // Validate the table name.
766                 tableName = getTableNameToUse(tableName);
767                 return getValidListViewLayoutGroup(tableName, localeID);
768         }
769
770         /**
771          * Gets the table name to use when accessing the database and the document. This method guards against SQL injection
772          * attacks by returning the default table if the requested table is not in the database or if the table name has not
773          * been set.
774          * 
775          * @param tableName
776          *            The table name to validate.
777          * @return The table name to use.
778          */
779         private String getTableNameToUse(final String tableName) {
780                 if (StringUtils.isEmpty(tableName) || !document.getTableIsKnown(tableName)) {
781                         return document.getDefaultTable();
782                 }
783                 return tableName;
784         }
785
786         /**
787          * @param tableName
788          * @param localeID
789          * @return
790          */
791         public Reports getReports(final String tableName, final String localeID) {
792                 final Reports result = new Reports();
793
794                 final List<String> names = document.getReportNames(tableName);
795
796                 final int count = Utils.safeLongToInt(names.size());
797                 for (int i = 0; i < count; i++) {
798                         final String name = names.get(i);
799                         final Report report = document.getReport(tableName, name);
800                         if (report == null) {
801                                 continue;
802                         }
803
804                         final String title = report.getTitle(localeID);
805                         result.addReport(name, title);
806                 }
807
808                 return result;
809         }
810 }