gitorious.org Git - online-glom:gwt-glom.git/blob - src/main/java/org/glom/web/server/ConfiguredDocument.java

1 /*

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 }