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

27 import org.glom.libglom.Document;

28 import org.glom.libglom.Field;

29 import org.glom.libglom.FieldFormatting;

30 import org.glom.libglom.FieldVector;

31 import org.glom.libglom.Glom;

32 import org.glom.libglom.LayoutGroupVector;

33 import org.glom.libglom.LayoutItemVector;

34 import org.glom.libglom.LayoutItem_CalendarPortal;

35 import org.glom.libglom.LayoutItem_Field;

36 import org.glom.libglom.LayoutItem_Notebook;

37 import org.glom.libglom.LayoutItem_Portal;

38 import org.glom.libglom.NumericFormat;

39 import org.glom.libglom.Relationship;

40 import org.glom.libglom.StringVector;

41 import org.glom.web.server.database.DetailsDBAccess;

42 import org.glom.web.server.database.ListViewDBAccess;

43 import org.glom.web.server.database.RelatedListDBAccess;

44 import org.glom.web.server.database.RelatedListNavigation;

45 import org.glom.web.shared.DataItem;

46 import org.glom.web.shared.DocumentInfo;

47 import org.glom.web.shared.GlomNumericFormat;

48 import org.glom.web.shared.NavigationRecord;

49 import org.glom.web.shared.TypedDataItem;

50 import org.glom.web.shared.layout.Formatting;

51 import org.glom.web.shared.layout.LayoutGroup;

52 import org.glom.web.shared.layout.LayoutItem;

53 import org.glom.web.shared.layout.LayoutItemField;

54 import org.glom.web.shared.layout.LayoutItemNotebook;

55 import org.glom.web.shared.layout.LayoutItemPortal;

56

57 import com.mchange.v2.c3p0.ComboPooledDataSource;

58

59 /**

60 * A class to hold configuration information for a given Glom document. This class is used to retrieve layout

61 * information from libglom and data from the underlying PostgreSQL database.

62 *

63 * @author Ben Konrath <ben@bagu.org>

64 *

65 */

66 final class ConfiguredDocument {

67

68 private Document document;

69 private ComboPooledDataSource cpds;

70 private boolean authenticated = false;

71 private String documentID;

72

73 @SuppressWarnings("unused")

74 private ConfiguredDocument() {

75 // disable default constructor

76 }

77

78 ConfiguredDocument(Document document) throws PropertyVetoException {

79

80 // load the jdbc driver

81 cpds = new ComboPooledDataSource();

82

83 // We don't support sqlite or self-hosting yet.

84 if (document.get_hosting_mode() != Document.HostingMode.HOSTING_MODE_POSTGRES_CENTRAL) {

85 Log.fatal("Error configuring the database connection." + " Only central PostgreSQL hosting is supported.");

86 // FIXME: Throw exception?

87 }

88

89 try {

90 cpds.setDriverClass("org.postgresql.Driver");

91 } catch (PropertyVetoException e) {

92 Log.fatal("Error loading the PostgreSQL JDBC driver."

93 + " Is the PostgreSQL JDBC jar available to the servlet?", e);

94 throw e;

95 }

96

97 // setup the JDBC driver for the current glom document

98 cpds.setJdbcUrl("jdbc:postgresql://" + document.get_connection_server() + ":" + document.get_connection_port()

99 + "/" + document.get_connection_database());

100

101 this.document = document;

102 }

103

104 /**

105 * Sets the username and password for the database associated with the Glom document.

106 *

107 * @return true if the username and password works, false otherwise

108 */

109 boolean setUsernameAndPassword(String username, String password) throws SQLException {

110 cpds.setUser(username);

111 cpds.setPassword(password);

112

113 int acquireRetryAttempts = cpds.getAcquireRetryAttempts();

114 cpds.setAcquireRetryAttempts(1);

115 Connection conn = null;

116 try {

117 // FIXME find a better way to check authentication

118 // it's possible that the connection could be failing for another reason

119 conn = cpds.getConnection();

120 authenticated = true;

121 } catch (SQLException e) {

122 Log.info(Utils.getFileName(document.get_file_uri()), e.getMessage());

123 Log.info(Utils.getFileName(document.get_file_uri()),

124 "Connection Failed. Maybe the username or password is not correct.");

125 authenticated = false;

126 } finally {

127 if (conn != null)

128 conn.close();

129 cpds.setAcquireRetryAttempts(acquireRetryAttempts);

130 }

131 return authenticated;

132 }

133

134 Document getDocument() {

135 return document;

136 }

137

138 ComboPooledDataSource getCpds() {

139 return cpds;

140 }

141

142 boolean isAuthenticated() {

143 return authenticated;

144 }

145

146 String getDocumentID() {

147 return documentID;

148 }

149

150 void setDocumentID(String documentID) {

151 this.documentID = documentID;

152 }

153

154 /**

155 * @return

156 */

157 DocumentInfo getDocumentInfo() {

158 DocumentInfo documentInfo = new DocumentInfo();

159

160 // get arrays of table names and titles, and find the default table index

161 StringVector tablesVec = document.get_table_names();

162

163 int numTables = Utils.safeLongToInt(tablesVec.size());

164 // we don't know how many tables will be hidden so we'll use half of the number of tables for the default size

165 // of the ArrayList

166 ArrayList<String> tableNames = new ArrayList<String>(numTables / 2);

167 ArrayList<String> tableTitles = new ArrayList<String>(numTables / 2);

168 boolean foundDefaultTable = false;

169 int visibleIndex = 0;

170 for (int i = 0; i < numTables; i++) {

171 String tableName = tablesVec.get(i);

172 if (!document.get_table_is_hidden(tableName)) {

173 tableNames.add(tableName);

174 // JNI is "expensive", the comparison will only be called if we haven't already found the default table

175 if (!foundDefaultTable && tableName.equals(document.get_default_table())) {

176 documentInfo.setDefaultTableIndex(visibleIndex);

177 foundDefaultTable = true;

178 }

179 tableTitles.add(document.get_table_title(tableName));

180 visibleIndex++;

181 }

182 }

183

184 // set everything we need

185 documentInfo.setTableNames(tableNames);

186 documentInfo.setTableTitles(tableTitles);

187 documentInfo.setTitle(document.get_database_title());

188

189 return documentInfo;

190 }

191

192 /*

193 * Gets the layout group for the list view using the defined layout list in the document or the table fields if

194 * there's no defined layout group for the list view.

195 */

196 private org.glom.libglom.LayoutGroup getValidListViewLayoutGroup(String tableName) {

197

198 LayoutGroupVector layoutGroupVec = document.get_data_layout_groups("list", tableName);

199

200 int listViewLayoutGroupSize = Utils.safeLongToInt(layoutGroupVec.size());

201 org.glom.libglom.LayoutGroup libglomLayoutGroup = null;

202 if (listViewLayoutGroupSize > 0) {

203 // a list layout group is defined; we can use the first group as the list

204 if (listViewLayoutGroupSize > 1)

205 Log.warn(documentID, tableName, "The size of the list layout group is greater than 1. "

206 + "Attempting to use the first item for the layout list view.");

207

208 libglomLayoutGroup = layoutGroupVec.get(0);

209 } else {

210 // a list layout group is *not* defined; we are going make a libglom layout group from the list of fields

211 Log.info(documentID, tableName,

212 "A list layout is not defined for this table. Displaying a list layout based on the field list.");

213

214 FieldVector fieldsVec = document.get_table_fields(tableName);

215 libglomLayoutGroup = new org.glom.libglom.LayoutGroup();

216 for (int i = 0; i < fieldsVec.size(); i++) {

217 Field field = fieldsVec.get(i);

218 LayoutItem_Field layoutItemField = new LayoutItem_Field();

219 layoutItemField.set_full_field_details(field);

220 libglomLayoutGroup.add_item(layoutItemField);

221 }

222 }

223

224 return libglomLayoutGroup;

225 }

226

227 ArrayList<DataItem[]> getListViewData(String tableName, int start, int length, boolean useSortClause,

228 int sortColumnIndex, boolean isAscending) {

229 // Validate the table name.

230 tableName = getTableNameToUse(tableName);

231

232 // Get the libglom LayoutGroup that represents the list view.

233 org.glom.libglom.LayoutGroup libglomLayoutGroup = getValidListViewLayoutGroup(tableName);

234

235 // Create a database access object for the list view.

236 ListViewDBAccess listViewDBAccess = new ListViewDBAccess(document, documentID, cpds, tableName,

237 libglomLayoutGroup);

238

239 // Return the data.

240 return listViewDBAccess.getData(start, length, useSortClause, sortColumnIndex, isAscending);

241 }

242

243 DataItem[] getDetailsData(String tableName, TypedDataItem primaryKeyValue) {

244 // Validate the table name.

245 tableName = getTableNameToUse(tableName);

246

247 DetailsDBAccess detailsDBAccess = new DetailsDBAccess(document, documentID, cpds, tableName);

248

249 return detailsDBAccess.getData(primaryKeyValue);

250 }

251

252 ArrayList<DataItem[]> getRelatedListData(String tableName, String relationshipName, TypedDataItem foreignKeyValue,

253 int start, int length, boolean useSortClause, int sortColumnIndex, boolean isAscending) {

254 // Validate the table name.

255 tableName = getTableNameToUse(tableName);

256

257 // Create a database access object for the related list

258 RelatedListDBAccess relatedListDBAccess = new RelatedListDBAccess(document, documentID, cpds, tableName,

259 relationshipName);

260

261 // Return the data

262 return relatedListDBAccess.getData(start, length, foreignKeyValue, useSortClause, sortColumnIndex, isAscending);

263 }

264

265 ArrayList<LayoutGroup> getDetailsLayoutGroup(String tableName) {

266 // Validate the table name.

267 tableName = getTableNameToUse(tableName);

268

269 // Get the details layout group information for each LayoutGroup in the LayoutGroupVector

270 LayoutGroupVector layoutGroupVec = document.get_data_layout_groups("details", tableName);

271 ArrayList<LayoutGroup> layoutGroups = new ArrayList<LayoutGroup>();

272 for (int i = 0; i < layoutGroupVec.size(); i++) {

273 org.glom.libglom.LayoutGroup libglomLayoutGroup = layoutGroupVec.get(i);

274

275 // satisfy the precondition of getDetailsLayoutGroup(String, org.glom.libglom.LayoutGroup)

276 if (libglomLayoutGroup == null)

277 continue;

278

279 layoutGroups.add(getDetailsLayoutGroup(tableName, libglomLayoutGroup));

280 }

281

282 return layoutGroups;

283 }

284

285 LayoutGroup getListViewLayoutGroup(String tableName) {

286 // Validate the table name.

287 tableName = getTableNameToUse(tableName);

288

289 org.glom.libglom.LayoutGroup libglomLayoutGroup = getValidListViewLayoutGroup(tableName);

290

291 return getListLayoutGroup(tableName, libglomLayoutGroup);

292 }

293

294 /*

295 * Gets the expected row count for a related list.

296 */

297 int getRelatedListRowCount(String tableName, String relationshipName, TypedDataItem foreignKeyValue) {

298 // Validate the table name.

299 tableName = getTableNameToUse(tableName);

300

301 // Create a database access object for the related list

302 RelatedListDBAccess relatedListDBAccess = new RelatedListDBAccess(document, documentID, cpds, tableName,

303 relationshipName);

304

305 // Return the row count

306 return relatedListDBAccess.getExpectedResultSize(foreignKeyValue);

307 }

308

309 NavigationRecord getSuitableRecordToViewDetails(String tableName, String relationshipName,

310 TypedDataItem primaryKeyValue) {

311 // Validate the table name.

312 tableName = getTableNameToUse(tableName);

313

314 RelatedListNavigation relatedListNavigation = new RelatedListNavigation(document, documentID, cpds, tableName,

315 relationshipName);

316

317 return relatedListNavigation.getNavigationRecord(primaryKeyValue);

318 }

319

320 /*

321 * Gets a LayoutGroup DTO for the given table name and libglom LayoutGroup. This method can be used for the main

322 * list view table and for the related list table.

323 */

324 private LayoutGroup getListLayoutGroup(String tableName, org.glom.libglom.LayoutGroup libglomLayoutGroup) {

325 LayoutGroup layoutGroup = new LayoutGroup();

326 int primaryKeyIndex = -1;

327

328 // look at each child item

329 LayoutItemVector layoutItemsVec = libglomLayoutGroup.get_items();

330 int numItems = Utils.safeLongToInt(layoutItemsVec.size());

331 for (int i = 0; i < numItems; i++) {

332 org.glom.libglom.LayoutItem libglomLayoutItem = layoutItemsVec.get(i);

333

334 // TODO add support for other LayoutItems (Text, Image, Button etc.)

335 LayoutItem_Field libglomLayoutItemField = LayoutItem_Field.cast_dynamic(libglomLayoutItem);

336 if (libglomLayoutItemField != null) {

337 layoutGroup.addItem(convertToGWTGlomLayoutItemField(libglomLayoutItemField, false));

338 Field field = libglomLayoutItemField.get_full_field_details();

339 if (field.get_primary_key())

340 primaryKeyIndex = i;

341 } else {

342 Log.info(documentID, tableName,

343 "Ignoring unknown list LayoutItem of type " + libglomLayoutItem.get_part_type_name() + ".");

344 continue;

345 }

346 }

347

348 // set the expected result size for list view tables

349 ListViewDBAccess listViewDBAccess = new ListViewDBAccess(document, documentID, cpds, tableName,

350 libglomLayoutGroup);

351 layoutGroup.setExpectedResultSize(listViewDBAccess.getExpectedResultSize());

352

353 // Set the primary key index for the table

354 if (primaryKeyIndex < 0) {

355 // Add a LayoutItemField for the primary key to the end of the item list in the LayoutGroup because it

356 // doesn't already contain a primary key.

357 Field primaryKey = null;

358 FieldVector fieldsVec = document.get_table_fields(tableName);

359 for (int i = 0; i < Utils.safeLongToInt(fieldsVec.size()); i++) {

360 Field field = fieldsVec.get(i);

361 if (field.get_primary_key()) {

362 primaryKey = field;

363 break;

364 }

365 }

366 if (primaryKey != null) {

367 LayoutItem_Field libglomLayoutItemField = new LayoutItem_Field();

368 libglomLayoutItemField.set_full_field_details(primaryKey);

369 layoutGroup.addItem(convertToGWTGlomLayoutItemField(libglomLayoutItemField, false));

370 layoutGroup.setPrimaryKeyIndex(layoutGroup.getItems().size() - 1);

371 layoutGroup.setHiddenPrimaryKey(true);

372 } else {

373 Log.error(document.get_database_title(), tableName,

374 "A primary key was not found in the FieldVector for this table. Navigation buttons will not work.");

375 }

376

377 } else {

378 layoutGroup.setPrimaryKeyIndex(primaryKeyIndex);

379 }

380

381 layoutGroup.setTableName(tableName);

382

383 return layoutGroup;

384 }

385

386 /*

387 * Gets a recursively defined Details LayoutGroup DTO for the specified libglom LayoutGroup object. This is used for

388 * getting layout information for the details view.

389 *

390 * @param documentID Glom document identifier

391 *

392 * @param tableName table name in the specified Glom document

393 *

394 * @param libglomLayoutGroup libglom LayoutGroup to convert

395 *

396 * @precondition libglomLayoutGroup must not be null

397 *

398 * @return {@link LayoutGroup} object that represents the layout for the specified {@link

399 * org.glom.libglom.LayoutGroup}

400 */

401 private LayoutGroup getDetailsLayoutGroup(String tableName, org.glom.libglom.LayoutGroup libglomLayoutGroup) {

402 LayoutGroup layoutGroup = new LayoutGroup();

403 layoutGroup.setColumnCount(Utils.safeLongToInt(libglomLayoutGroup.get_columns_count()));

404 String layoutGroupTitle = libglomLayoutGroup.get_title();

405 if (layoutGroupTitle.isEmpty())

406 layoutGroup.setName(libglomLayoutGroup.get_name());

407 else

408 layoutGroup.setTitle(layoutGroupTitle);

409

410 // look at each child item

411 LayoutItemVector layoutItemsVec = libglomLayoutGroup.get_items();

412 for (int i = 0; i < layoutItemsVec.size(); i++) {

413 org.glom.libglom.LayoutItem libglomLayoutItem = layoutItemsVec.get(i);

414

415 // just a safety check

416 if (libglomLayoutItem == null)

417 continue;

418

419 org.glom.web.shared.layout.LayoutItem layoutItem = null;

420 org.glom.libglom.LayoutGroup group = org.glom.libglom.LayoutGroup.cast_dynamic(libglomLayoutItem);

421 if (group != null) {

422 // libglomLayoutItem is a LayoutGroup

423 LayoutItem_Portal libglomLayoutItemPortal = LayoutItem_Portal.cast_dynamic(group);

424 if (libglomLayoutItemPortal != null) {

425 // group is a LayoutItem_Portal

426 LayoutItemPortal layoutItemPortal = createLayoutItemPortalDTO(tableName, libglomLayoutItemPortal);

427 if (layoutItemPortal == null)

428 continue;

429 layoutItem = layoutItemPortal;

430

431 } else {

432 // libglomLayoutItem is a LayoutGroup

433 LayoutItem_Notebook libglomLayoutItemNotebook = LayoutItem_Notebook.cast_dynamic(group);

434 if (libglomLayoutItemNotebook != null) {

435 // group is a LayoutItem_Notebook

436 LayoutGroup tempLayoutGroup = getDetailsLayoutGroup(tableName, libglomLayoutItemNotebook);

437 LayoutItemNotebook layoutItemNotebook = new LayoutItemNotebook();

438 for (LayoutItem item : tempLayoutGroup.getItems()) {

439 layoutItemNotebook.addItem(item);

440 }

441 layoutItemNotebook.setName(tableName);

442 layoutItem = layoutItemNotebook;

443 } else {

444 // group is *not* a LayoutItem_Portal or a LayoutItem_Notebook

445 // recurse into child groups

446 layoutItem = getDetailsLayoutGroup(tableName, group);

447 }

448 }

449 } else {

450 // libglomLayoutItem is *not* a LayoutGroup

451 // create LayoutItem DTOs based on the the libglom type

452 // TODO add support for other LayoutItems (Text, Image, Button etc.)

453 LayoutItem_Field libglomLayoutItemField = LayoutItem_Field.cast_dynamic(libglomLayoutItem);

454 if (libglomLayoutItemField != null) {

455

456 LayoutItemField layoutItemField = convertToGWTGlomLayoutItemField(libglomLayoutItemField, true);

457

458 // Set the full field details with updated field details from the document.

459 libglomLayoutItemField.set_full_field_details(document.get_field(

460 libglomLayoutItemField.get_table_used(tableName), libglomLayoutItemField.get_name()));

461

462 // Determine if the field should have a navigation button and set this in the DTO.

463 Relationship fieldUsedInRelationshipToOne = new Relationship();

464 boolean addNavigation = Glom.layout_field_should_have_navigation(tableName, libglomLayoutItemField,

465 document, fieldUsedInRelationshipToOne);

466 layoutItemField.setAddNavigation(addNavigation);

467

468 // Set the the name of the table to navigate to if navigation should be enabled.

469 if (addNavigation) {

470 // It's not possible to directly check if fieldUsedInRelationshipToOne is

471 // null because of the way that the glom_sharedptr macro works. This workaround accomplishes the

472 // same task.

473 String tableNameUsed;

474 try {

475 Relationship temp = new Relationship();

476 temp.equals(fieldUsedInRelationshipToOne); // this will throw an NPE if

477 // fieldUsedInRelationshipToOne is null

478 // fieldUsedInRelationshipToOne is *not* null

479 tableNameUsed = fieldUsedInRelationshipToOne.get_to_table();

480

481 } catch (NullPointerException e) {

482 // fieldUsedInRelationshipToOne is null

483 tableNameUsed = libglomLayoutItemField.get_table_used(tableName);

484 }

485

486 // Set the navigation table name only if it's not different than the current table name.

487 if (!tableName.equals(tableNameUsed)) {

488 layoutItemField.setNavigationTableName(tableNameUsed);

489 }

490 }

491

492 layoutItem = layoutItemField;

493

494 } else {

495 Log.info(documentID, tableName,

496 "Ignoring unknown details LayoutItem of type " + libglomLayoutItem.get_part_type_name()

497 + ".");

498 continue;

499 }

500 }

501

502 layoutGroup.addItem(layoutItem);

503 }

504

505 return layoutGroup;

506 }

507

508 private LayoutItemPortal createLayoutItemPortalDTO(String tableName,

509 org.glom.libglom.LayoutItem_Portal libglomLayoutItemPortal) {

510

511 // Ignore LayoutItem_CalendarPortals for now:

512 // https://bugzilla.gnome.org/show_bug.cgi?id=664273

513 LayoutItem_CalendarPortal liblglomLayoutItemCalendarPortal = LayoutItem_CalendarPortal

514 .cast_dynamic(libglomLayoutItemPortal);

515 if (liblglomLayoutItemCalendarPortal != null)

516 return null;

517

518 LayoutItemPortal layoutItemPortal = new LayoutItemPortal();

519 Relationship relationship = libglomLayoutItemPortal.get_relationship();

520 if (relationship != null) {

521 layoutItemPortal.setNavigationType(convertToGWTGlomNavigationType(libglomLayoutItemPortal

522 .get_navigation_type()));

523

524 layoutItemPortal.setTitle(libglomLayoutItemPortal.get_title_used("")); // parent title not relevant

525 layoutItemPortal.setName(libglomLayoutItemPortal.get_relationship_name_used());

526 layoutItemPortal.setTableName(relationship.get_from_table());

527 layoutItemPortal.setFromField(relationship.get_from_field());

528

529 // convert the portal layout items into LayoutItemField DTOs

530 LayoutItemVector layoutItemsVec = libglomLayoutItemPortal.get_items();

531 long numItems = layoutItemsVec.size();

532 for (int i = 0; i < numItems; i++) {

533 org.glom.libglom.LayoutItem libglomLayoutItem = layoutItemsVec.get(i);

534

535 // TODO add support for other LayoutItems (Text, Image, Button etc.)

536 LayoutItem_Field libglomLayoutItemField = LayoutItem_Field.cast_dynamic(libglomLayoutItem);

537 if (libglomLayoutItemField != null) {

538 // TODO EDITING If the relationship does not allow editing, then mark all these fields as

539 // non-editable. Check relationship.get_allow_edit() to see if it's editable.

540 layoutItemPortal.addItem(convertToGWTGlomLayoutItemField(libglomLayoutItemField, false));

541 } else {

542 Log.info(documentID, tableName, "Ignoring unknown related list LayoutItem of type "

543 + libglomLayoutItem.get_part_type_name() + ".");

544 continue;

545 }

546 }

547

548 // get the primary key for the related list table

549 LayoutItem_Field layoutItemField = new LayoutItem_Field();

550 String toTableName = relationship.get_to_table();

551 String toFieldName = libglomLayoutItemPortal.get_to_field_used();

552 if (!toFieldName.isEmpty() && !toTableName.isEmpty()) {

553

554 // get the LayoutItem_Feild with details from its Field in the document

555 FieldVector fields = document.get_table_fields(toTableName);

556 numItems = fields.size(); // reuse loop variable from above

557 for (int i = 0; i < numItems; i++) {

558 Field field = fields.get(i);

559 // check the names to see if they're the same

560 if (toFieldName.equals(field.get_name())) {

561 layoutItemField.set_full_field_details(field);

562 layoutItemPortal.addItem(convertToGWTGlomLayoutItemField(layoutItemField, false));

563 layoutItemPortal.setPrimaryKeyIndex(layoutItemPortal.getItems().size() - 1);

564 layoutItemPortal.setHiddenPrimaryKey(true); // always hidden in portals

565 }

566 }

567 }

568

569 // Set whether or not the related list will need to show the navigation buttons.

570 // This was ported from Glom: Box_Data_Portal::get_has_suitable_record_to_view_details()

571 StringBuffer navigationTableName = new StringBuffer();

572 LayoutItem_Field navigationRelationship = new LayoutItem_Field(); // Ignored.

573 libglomLayoutItemPortal.get_suitable_table_to_view_details(navigationTableName, navigationRelationship,

574 document);

575 layoutItemPortal.setAddNavigation(!(navigationTableName.toString().isEmpty()));

576 }

577

578 // Note: An empty LayoutItemPortal is returned if relationship is null.

579 return layoutItemPortal;

580 }

581

582 private GlomNumericFormat convertNumbericFormat(NumericFormat libglomNumericFormat) {

583 GlomNumericFormat gnf = new GlomNumericFormat();

584 gnf.setUseAltForegroundColourForNegatives(libglomNumericFormat.get_alt_foreground_color_for_negatives());

585 gnf.setCurrencyCode(libglomNumericFormat.get_currency_symbol());

586 gnf.setDecimalPlaces(Utils.safeLongToInt(libglomNumericFormat.get_decimal_places()));

587 gnf.setDecimalPlacesRestricted(libglomNumericFormat.get_decimal_places_restricted());

588 gnf.setUseThousandsSeparator(libglomNumericFormat.get_use_thousands_separator());

589 return gnf;

590 }

591

592 private Formatting convertFormatting(FieldFormatting libglomFormatting) {

593 Formatting formatting = new Formatting();

594

595 // text colour

596 String foregroundColour = libglomFormatting.get_text_format_color_foreground();

597 if (foregroundColour != null && !foregroundColour.isEmpty())

598 formatting.setTextFormatColourForeground(convertGdkColorToHtmlColour(foregroundColour));

599 String backgroundColour = libglomFormatting.get_text_format_color_background();

600 if (backgroundColour != null && !backgroundColour.isEmpty())

601 formatting.setTextFormatColourBackground(convertGdkColorToHtmlColour(backgroundColour));

602

603 // multiline

604 if (libglomFormatting.get_text_format_multiline()) {

605 formatting.setTextFormatMultilineHeightLines(Utils.safeLongToInt(libglomFormatting

606 .get_text_format_multiline_height_lines()));

607 }

608

609 return formatting;

610 }

611

612 private LayoutItemField convertToGWTGlomLayoutItemField(LayoutItem_Field libglomLayoutItemField,

613 boolean forDetailsView) {

614 LayoutItemField layoutItemField = new LayoutItemField();

615

616 // set type

617 layoutItemField.setType(convertToGWTGlomFieldType(libglomLayoutItemField.get_glom_type()));

618

619 // set title and name

620 layoutItemField.setTitle(libglomLayoutItemField.get_title_or_name());

621 layoutItemField.setName(libglomLayoutItemField.get_name());

622

623 // convert formatting

624 FieldFormatting glomFormatting = libglomLayoutItemField.get_formatting_used();

625 Formatting formatting = convertFormatting(glomFormatting);

626

627 // set horizontal alignment

628 org.glom.libglom.FieldFormatting.HorizontalAlignment libglomHorizontalAlignment = libglomLayoutItemField

629 .get_formatting_used_horizontal_alignment(forDetailsView); // only returns LEFT or RIGHT

630 Formatting.HorizontalAlignment horizontalAlignment;

631 if (libglomHorizontalAlignment == org.glom.libglom.FieldFormatting.HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT) {

632 horizontalAlignment = Formatting.HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT;

633 } else {

634 horizontalAlignment = Formatting.HorizontalAlignment.HORIZONTAL_ALIGNMENT_RIGHT;

635 }

636 formatting.setHorizontalAlignment(horizontalAlignment);

637

638 // create a GlomNumericFormat DTO for numeric values

639 if (libglomLayoutItemField.get_glom_type() == org.glom.libglom.Field.glom_field_type.TYPE_NUMERIC) {

640 formatting.setGlomNumericFormat(convertNumbericFormat(glomFormatting.get_numeric_format()));

641 }

642 layoutItemField.setFormatting(formatting);

643

644 return layoutItemField;

645 }

646

647 /*

648 * This method converts a Field.glom_field_type to the equivalent ColumnInfo.FieldType. The need for this comes from

649 * the fact that the GWT FieldType classes can't be used with RPC and there's no easy way to use the java-libglom

650 * Field.glom_field_type enum with RPC. An enum identical to FieldFormatting.glom_field_type is included in the

651 * ColumnInfo class.

652 */

653 private LayoutItemField.GlomFieldType convertToGWTGlomFieldType(Field.glom_field_type type) {

654 switch (type) {

655 case TYPE_BOOLEAN:

656 return LayoutItemField.GlomFieldType.TYPE_BOOLEAN;

657 case TYPE_DATE:

658 return LayoutItemField.GlomFieldType.TYPE_DATE;

659 case TYPE_IMAGE:

660 return LayoutItemField.GlomFieldType.TYPE_IMAGE;

661 case TYPE_NUMERIC:

662 return LayoutItemField.GlomFieldType.TYPE_NUMERIC;

663 case TYPE_TEXT:

664 return LayoutItemField.GlomFieldType.TYPE_TEXT;

665 case TYPE_TIME:

666 return LayoutItemField.GlomFieldType.TYPE_TIME;

667 case TYPE_INVALID:

668 Log.info("Returning TYPE_INVALID.");

669 return LayoutItemField.GlomFieldType.TYPE_INVALID;

670 default:

671 Log.error("Recieved a type that I don't know about: " + Field.glom_field_type.class.getName() + "."

672 + type.toString() + ". Returning " + LayoutItemField.GlomFieldType.TYPE_INVALID.toString() + ".");

673 return LayoutItemField.GlomFieldType.TYPE_INVALID;

674 }

675 }

676

677 /*

678 * Converts a Gdk::Color (16-bits per channel) to an HTML colour (8-bits per channel) by discarding the least

679 * significant 8-bits in each channel.

680 */

681 private String convertGdkColorToHtmlColour(String gdkColor) {

682 if (gdkColor.length() == 13)

683 return gdkColor.substring(0, 3) + gdkColor.substring(5, 7) + gdkColor.substring(9, 11);

684 else if (gdkColor.length() == 7) {

685 // This shouldn't happen but let's deal with it if it does.

686 Log.warn(documentID,

687 "Expected a 13 character string but received a 7 character string. Returning received string.");

688 return gdkColor;

689 } else {

690 Log.error("Did not receive a 13 or 7 character string. Returning black HTML colour code.");

691 return "#000000";

692 }

693 }

694

695 /*

696 * This method converts a LayoutItem_Portal.navigation_type from java-libglom to the equivalent

697 * LayoutItemPortal.NavigationType from Online Glom. This conversion is required because the LayoutItem_Portal class

698 * from java-libglom can't be used with GWT-RPC. An enum identical to LayoutItem_Portal.navigation_type from

699 * java-libglom is included in the LayoutItemPortal data transfer object.

700 */

701 private LayoutItemPortal.NavigationType convertToGWTGlomNavigationType(

702 LayoutItem_Portal.navigation_type navigationType) {

703 switch (navigationType) {

704 case NAVIGATION_NONE:

705 return LayoutItemPortal.NavigationType.NAVIGATION_NONE;

706 case NAVIGATION_AUTOMATIC:

707 return LayoutItemPortal.NavigationType.NAVIGATION_AUTOMATIC;

708 case NAVIGATION_SPECIFIC:

709 return LayoutItemPortal.NavigationType.NAVIGATION_SPECIFIC;

710 default:

711 Log.error("Recieved an unknown NavigationType: " + LayoutItem_Portal.navigation_type.class.getName() + "."

712 + navigationType.toString() + ". Returning " + LayoutItemPortal.NavigationType.NAVIGATION_AUTOMATIC

713 + ".");

714 return LayoutItemPortal.NavigationType.NAVIGATION_AUTOMATIC;

715 }

716 }

717

718 /**

719 * Gets the table name to use when accessing the database and the document. This method guards against SQL injection

720 * attacks by returning the default table if the requested table is not in the database or if the table name has not

721 * been set.

722 *

723 * @param tableName

724 * The table name to validate.

725 * @return The table name to use.

726 */

727 private String getTableNameToUse(String tableName) {

728 if (tableName == null || tableName.isEmpty() || !document.get_table_is_known(tableName)) {

729 return document.get_default_table();

730 }

731 return tableName;

732 }

733

734 }