XPages Development 2 for Notes and Domino 9
Units: 16
Duration: 4 classroom equivalent days
Discussion Access: 12 months


Summary Description
Take your XPage development skills to the next level with the XPages Development 2 course! This course picks up after TLCC's XPages Development 1 course. This course concentrates on the skills needed to move your traditional Notes/Domino applications to XPages and to enhance your applications using the latest Web 2.0 tools. Learn how to optimize your application by understanding XPage architecture, specific uses for Custom Controls, use Dojo to add Web 2.0 features, and use partial refresh and execution to speed up your application. Take advantage of the native charting capability that Domino developers have never had using the Dojox library to create different types of charts and graphs. Provide your users an alternative to Domino views with the Dojo DataGrid widget that can provide filtering and searching along with in-grid editing of data. Learn how to call Domio agents from Server-side JavaScript to take advantage of existing LotusScript code. Create XAgents to output XML and JSON data and use XML as a data source on your XPage. Learn how to optimize the use of views on an XPage such as expanding and collapsing all categories via a control, fixing display issues with categories, and returning the user back to the page from where they opened a document. Add the abillity to interact with relational data in XPages using the Relational Controls from the Extension Library. Learn how to use relational data as a data source for View Panel, Repeat, and Data Table controls. Use the new @Functions to enable Server-side JavaScript to read and write relational data on your XPages. Finally, this course will show you how to localize your XPages for different languages.
With this TLCC course, like all TLCC courses, you are not watching videos or just listening to a speaker, you get hands-on experience in Domino Designer. Just about every topic has a demonstration of the techniques used in the lesson. Then you will perform an activity to give you the skills and confidence you need to be productive.

Audience and Prerequisites
Experienced Notes and Domino application developers with XPages development experience. Experience with JavaScript and the Domino Object Model (LotusScript or Java) is also strongly suggested.
Click here to view the complete skills path for XPages development.
The following TLCC courses (or their equivalent) are prerequisite for this course:
  • JavaScript for XPages Development (9.0)
  • XPages Development 1 for Notes and Domino 9.0

System Requirements
The system requirements for this course are:
Course Modules

Module 1 - XPages Application Architecture
This module covers the XPages application architecture. Learn how the XPages lifecycle and programmable events affect XPage design considerations and options. Understand the XPages lifecycle phases and how the Partial Refresh and Partial Execution settings can improve performance. Learn how to determine which client is in use to optimize support for various web browsers as well as the Notes client. This module also covers the design considerations when converting existing Domino applications to XPages and how to add meta tag data to an XPage. Learn how Single Copy XPage Design is implemented and how it will improve the performance of applications with the same or similar design. Learn how to translate an XPage application to different languages (localization).
  • Understand the XPages lifecycle phases
  • Optimize XPages performance using Partial Refresh and Partial Execution
  • Determine what XPage events will be triggered and in which order they are triggered
  • Code the querySaveDocument event to prevent the submission of a document
  • Understand how XPages in the Notes client ( XPiNC) works and the available setting to optimize performance
  • Use methods from the XSPUserAgent class to determine which browser and version is in use
  • Use @ClientType to determine if the client is either Notes or a web browser
  • Understand the design considerations for migrating existing Domino forms, views and agents to XPages
  • Add meta tag data to Custom Controls and XPages
  • Implement Single Copy XPage Design to improve the performance of applications with the same or similar design
  • Understand the necessary steps to implement language localization for XPages
  • Localize static strings in JavaScript code

Module 2 - Custom Controls
Custom Controls are an integral part of efficient XPage design. Learn how to design a Custom Control that can access data sources on the parent XPage and understand the scope of data sources defined in a Custom Control. Pass a data source as a property to a Custom Control. Create Custom Controls to be used for document navigation and for adding Authors and Readers fields. Learn how to dynamically display a Custom Control based on a criteria in the XPage such as a selection made by the user. Use properties in the Custom Control to define a "View" Custom Control used on multiple XPages that specifies which XPage to load when the user clicks on a document in the view.
  • Understand the implications of where the data source is defined in a XPage that has multiple Custom Controls
  • Understand the scope of data sources defined in a Custom Control
  • Pass a data source as a property to a Custom Control
  • Create a Custom Control to easily include common document navigation buttons
  • Use a Custom Control to add the Authors and Readers Names fields to the document
  • Access Custom Control components using both Client-side and Server-side JavaScript
  • Dynamically display a Custom Control based on a condition or selection on the XPage
  • Use Custom Control Properties to allow a "View" Custom Control to load different XPages when a document is clicked

Module 3 - Advanced Client-side JavaScript
This module starts with how to use web development tools like the integrated Chrome Developer Tools and Firebug Lite for the Notes client to debug Client-side JavaScript. Several key functions of the XSP Client-side JavaScript Object are explored and used, and a technique to chain partial refreshes is also reviewed. Learn how to code an event handler to execute Client-side JavaScript after the Server-side JavaScript request is completed. This module continues with an in-depth look at the additional functionality and features provided by the included Dojo JavaScript toolkit. Use the functions in the Dojo Base library to work with Arrays, the Web DOM and JSON data. Add modules from the Dojo Core library to format date and currency values. Use the DojoX Charting modules to chart data from a Domino application. Finally, learn how to include other JavaScript libraries like jQuery in an XPage application.
  • Debug Client-side JavaScript
  • Learn and use several key functions of the XSP Client-side JavaScript Object
  • Use the onComplete event to run Client-side JavaScript after a request is completed
  • Perform multiple partial refreshes to refresh discontinuous components on an XPage
  • Learn how to use the Dojo toolkit that is included in XPages to add more functionality to your Client-side JavaScript
  • Use the functions in the Dojo Base library to work with Arrays, the Web DOM and JSON data
  • Add modules from the Dojo Core library to format date and currency values
  • Implement a Dojo Dijit control both declaratively and programmatically to improve usability
  • Use the DojoX Charting modules to create pie, column, and other types of charts using data from a Domino application
  • Include other JavaScript libraries like jQuery in an XPage application

Module 4 - Advanced Server-side JavaScript
This module covers advanced XPage techniques using Server-side JavaScript. Many existing Notes/Domino applications have legacy LotusScript agents that contain core business logic. Learn how to call these existing Domino agents from Server-side JavaScript (SSJS) and how to modify these agents to best work with XPages. Convert an existing LotusScript or Java WebQuerySave Agent to work with XPages. Design an XPage as an XAgent to produce output in alternative data formats like XML, JSON or HTML. Techniques for using XML data as a data source are also covered in this module. Finally, learn how to debug Server-side JavaScript including logging information to a Domino application and using the Server-side JavaScript Debugger.
  • Run a Domino LotusScript or Java agent from Server-side JavaScript
  • Understand the limitations and considerations for running an agent from an XPage
  • Convert a WebQuerySave Agent to work with an XPage
  • Create an XAgent to retrieve Domino data and output it as XML
  • Create an XAgent to retrieve Domino data and output it as JSON
  • Use XML data as the data source in an XPage and style using an XLST Stylesheet
  • Use XML data as the data source for a Data Table control on an XPage
  • Debug Server-side JavaScript by logging information to a Domino Log application
  • Use the Server-side JavaScript Debugger

Module 5 - Interacting with Domino Objects
This module covers how to implement some traditional Domino development frameworks and techniques in XPage applications. One example is implementing document field inheritance with XPages. Another topic compares different approaches to restore the state of a Domino view rendered on an XPage so the user sees the view exactly as they left it before opening another page. Learn techniques to optimize the display and performance of the categorized views in an XPage application.
  • Implement document inheritance in XPages
  • Explore and compare different approaches to restore the state of a Domino view
  • Optimize the display and performance of the categorized views in an XPage application

Module 6 - Dojo Data Grid
This mode introduces the Dojo Data Grid as an alternative for displaying the contents of a Domino view. A Dojo Data Grid can be a much better way to display data in a browser since all data is cached in the browser providing an improved user experience. Learn how custom columns can be used to provide formatting and sorting of a Data Grid and enable concatenating the field values from multiple columns for each view entry. Enable searching and filtering capabilities in the Dojo Data Grid in addition to displaying multi-row entries, editing documents using in-grid editing, and deleting selected row entries. Several techniques for creating and opening documents from a Dojo Data Grid are also covered. Learn how to aggregate data from multiple Domino applications using a Custom REST Service and then how to specify the JSON output of the REST service as the data store for a Dojo Data Grid control. Finally, an alternate filtering approach using the filter plugin of the Dojo Enhanced Grid is covered.
  • Display the entries from a Domino view in a Dojo Data Grid control
  • Add a custom column with Pass-thru HTML
  • Disable and enable column sorting
  • Concatenate field values in a custom column
  • Add and use system columns and code the onRowClick event
  • Format a column with a formatter function
  • Enable search in a Dojo Data Grid including searching for text in a specified field
  • Design grids with multi-row entries
  • Enable in-grid editing of the Domino data
  • Provide background styling for any changed rows and add a select editor and other column editors
  • Enable the deletion of selected row entries in a grid
  • Open a document from a grid by creating a custom column as a link or by coding the onRowDblClick event
  • Use either the two-page or one-page approach to allow users to create a document from a grid
  • Create and delete documents in a grid
  • Create a Custom REST Service to retrieve and aggregate data from multiple sources
  • Code an Output Script control to return the data store object from the Custom REST Service
  • Specify the data store object created in the script as the data store for the Dojo Data Grid
  • Enable filtering with a Dojo Enhanced Grid
  • Add Dojo attributes for the filter plugin

Module 7 - Relational Data Access using XPages
This module covers the requirements, installation, setup and usage of the relational data controls included with the current Extension Library from OpenNTF. Learn about the configuration requirements to enable a Domino application to use the relational controls. This module will describe and show how the two new relational data sources are used to enable both the display and editing of relational data in an XPages application. Learn how to display relational data in a View panel, Data Table, or Repeat control. Construct a SQL query to specify the data returned to a relational data source and to join data from two tables. Learn how the new Server-side JDBC @Functions can be used to perform actions such as creating, updating and deleting relational data. Learn how to also create and update relational data using the JDBCRowSet data source. Finally, learn how to display relational data in a Dojo Data Grid.
  • Understand the prerequisites and setup required to use the Relational Controls
  • Install the current OpenNTF Extension Library
  • Install the required Apache Derby database driver files to support the Designer local web preview server
  • Enable the relational controls library for the Domino application
  • Create a JDBC connection file (.jdbc) for each relational database to access
  • Use properties of the two new relational data sources to display relational data in a View control
  • Access individual records of the result set using the var variable for the containing View panel, Data Table, or Repeat control
  • Construct an SQL query in the sqlQuery property to define the data returned to the result set or to join data from two tables
  • Use Server-side JDBC @Functions to get a connection object, get a column of data, execute a SQL query, and to delete, insert or update table rows
  • Use the JDBCRowSet data source to create and update relational data
  • Determine the current state of a row of data to indicate to the user if changes were made but not yet committed
  • Display relational data in a Dojo Data Grid