|
Retail Price: |
$899 |
Course Code: |
ND9XPG1 |
Course Length (hours): |
28 |
Time Allowed: |
One Year |
Units: |
16
|
|
XPages Development 1 for Notes and Domino 9Print Course Information
XPages Development 1 for Notes and Domino 9 takes a deep dive into XPages, the revolutionary way to transform your Notes applications to modern Web 2.0 web and mobile applications. Learn the basic building blocks of XPages, from controls to coding events with the JavaScript editor. The available programming languages for XPages along with the various supporting libraries including the ported @Functions and the Domino Object Model are covered in detail. Discover how Cascading Style Sheets and Themes can be used to apply styles to your XPages and across all your applications. Another powerful design element, Custom Controls, allows controls to be easily re-used on multiple XPages (similar to a subform but much more powerful). This course also covers the use of XPages in the Notes client.
This course covers advanced techniques such as:
- Combine a view and a document on one page with complete edit capabilities
- Combine multiple documents or multiple views on a page
- Create dynamic tables with repeat controls
- Join data from different views and databases into one view
- Filter views to show only certain categories or the results of a full-text search
- Integrate Java in XPages
- Use the built-in AJAX functionality to enable type ahead and partial page refresh
- Display a responses-only column so it appears just like the Notes client
- Enable Authors and Readers fields
This distance learning course, like all TLCC courses, includes many demonstrations and activities you will do "live" in Domino Designer. No simulations or videos are used. You will get hands-on experience building XPages while learning at your own pace in your own home and/or office. A Domino server is not required and the course will install on your local system. Need help? An expert TLCC instructor is a click away via an integrated course discussion database.
XPages Development 1 is a complete and comprehensive course and not just a collection of sample exercises. You will gain a complete understanding of XPages and how this exciting technology can be used to enhance your new and existing Domino applications.
The course is one of five TLCC courses that will help prepare you for the two certification exams required to become an IBM Certified Application Developer - Notes and Domino 9.
Click here for more information on getting certified | |
The following TLCC courses (or their equivalent) are the suggested prerequisite(s) for this course:
Duration: 4 classroom equivalent days
Discussion Access: 12 months
Summary Description
Take a deep dive into XPages. All the XPage core controls are covered including how to validate data, show views, and use the provided simple actions. Learn the various programming options in XPages such as server-side JavaScript, the Expression language, and using the Java object model. Use CSS and Themes to format and style your XPages applications. Take advantage of the built-in AJAX support to provide field level type-ahead and partial page refresh of an XPage. Advanced techniques such as repeat controls, session and application variables, joining data from more than one view, combining views and documents on one XPage, building your own custom reusable controls, and Java integration are also covered in this comprehensive course. This course shows how XPages can be used to develop the user interface to an application that looks and functions the same on both Notes clients and web browsers.
This course will also help prepare you for the required exams to be certified as an IBM Certified Application Developer - Notes and Domino 9.
Audience and Prerequisites
Experienced Notes and Domino application developers. Experience with JavaScript and the Domino Object Model (LotusScript or Java) is also strongly suggested.
The following TLCC courses (or their equivalent) are recommended prerequisites for this course:
- Notes Domino 9.0 Application Development 1 (or Notes Domino 9.0 Application Development Update)
- JavaScript for XPages Development (9.0)
System Requirements
The system requirements for this course are:
- IBM Notes and Domino Designer 9.0
(This must be installed prior to installing this TLCC course.)
- A current web browser client
- Access to the Internet for instructor support
Course Modules
Module 1 - XPages Overview
This module provides an introduction to XPages development and an overview of the Eclipse based IDE used in Designer 9.0. The general XPage architecture as well as the XPages design features are discussed in this module. This module discusses the supported programming languages used in XPage design. The nature of the XPage design element, and the process and necessity of compiling the XPage source code in Designer is covered. Understand the considerations for rendering XPages in the Notes client such as launching the "Home XPage", applying different Themes for Notes and Web clients, and XPage security in the Notes client
- The Domino Designer interface in Eclipse (DDE)
- The general architecture and design features of XPages
- Supported programming languages used in XPage design including JavaScript, the Expression Language, @Functions, and Java
- Understand the nature of the XPage design element in context of compiling the XPage source code and compatibility considerations
- Considerations for rendering XPages in the Notes client such as launching the "Home XPage", applying different Themes for Notes and Web clients, and XPage security in the Notes client
Module 2 - Creating an XPage
This module covers the basic components used when creating an XPage. Understanding each of these basic components will provide you with the necessary skills to create an XPage. For example, learning how to add and use the different control types on an XPage, and understanding the importance of data sources and data bindings for creating XPages is covered in this module. You will discover how to use the new Domino Designer views such as the Outline, Properties and Events views necessary for XPage development. This module also demonstrates how to use simple actions and the JavaScript editor to code client-side and server-side events.
- Create a new XPage, add and format text, and then save and preview the XPage
- Troubleshoot errors
- The different control types available for XPage design
- Use The Outline view to select, move, and delete the XPage controls
- Use the Properties view to view and set properties for the various elements and controls on an XPage
- Dynamically compute properties
- Write Client-side and Server-side JavaScript that is triggered by events
- Invoke Simple Actions from Events
- Directly edit and view XPage source code
- Use the JavaScript Editor
- Use Domino data sources to connect XPages to views and documents
- Understand data binding of Domino fields to XPage controls
- Utilize the Data palette to drag and drop Domino fields onto an XPage
Module 3 - XPage Controls
This module covers the extensive palette of XPage controls available from the Controls palette in Domino Designer. This module covers these controls in logical categories such as Edit controls, Selection controls, Action controls, Display controls, Container controls and Error Display controls. The Controls palette categorizes the controls as either Core controls or Container controls. The core controls are common controls that appear as single entities in an XPage, whereas Container controls are more complex because they are designed to contain other controls.
- The edit/input controls used to display Domino fields such as the Edit Box, Multiline Edit Box, Date Time Picker, and Rich Text controls
- The selection controls such as the Combo Box, List Box, Check Box Group and Radio Button Group controls
- Use various techniques to control the list of choices shown to the user when using a ComboBox or ListBox control
- The action controls such as the Button, Link, File Upload and File Download controls
- Add buttons to an XPage to submit a page and control navigation between XPages
- Create buttons to perform simple actions such as switching between read and edit mode
- Use the display controls such as the Label, Image and Computed Field controls for displaying text or images when the page is rendered
- The different container controls such as Sections, Panel, Tables, Tabbed Panels, and Include Page controls
- Container controls used to display data such as the Repeat, and Data Table controls
- The Display Error and Display Errors controls to display error messages
Module 4 - XPages with Domino Views and Documents
This module covers the relationship between controls on an XPage and Domino data (views and documents.) We begin with an overview of the Domino design elements that are required to support XPage development, whether working with an existing Domino application, or creating a new one. Details on how to display a Domino view on an XPage are covered. Learn how to create an XPage that can be used to display, create, and edit Domino documents. Finally, the validation of data on an XPage is covered in this module.
- Understand the relationship between Domino design elements and XPages
- Use the computeWithForm property to utilize Domino form formulas (Default, Input Validation, and Input Translation)
- Display a Domino view on an XPage using a View control
- Control the XPage to be used when a user clicks on document in a View control
- Hide Controls on an XPage dynamically based on edit mode vs. read mode
- Set the properties for the View control including the pager, view column headers, and view columns
- Display and edit Domino documents using an XPage (read mode and edit mode)
- Design navigation buttons and links on an XPage for creating and saving a new document
- Create buttons to perform simple actions such as switching between read and edit mode
- Validate user entered data on an XPage
- Understand the difference between client-side and server-side validation and how to set validation properties
- Use the Display Error and Display Errors controls to display error messages
- Use advanced validators including regular expressions to validate data in XPage controls
Module 5 - Formatting and Styles
This module covers the use of Cascading Style Sheets (CSS) to change the look and feel of XPage applications. Formatting and styles can be applied directly to almost every control on an XPage through the Style tab in the Properties view. However, the best practice is to apply styles using an included Style Sheet that sets styles via Element, ID and Class attributes. Use Themes to control the look and feel of an entire application.
- A brief introduction to Cascading Style Sheets and how CSS is used to style a web page
- The XPage style properties and how they are used to provide style/formatting to individual XPage controls
- Create and add style sheets to an XPage
- Apply style sheet rules to elements/controls on an XPage
- Use the CSS Editor in Domino Designer
- Use an external CSS editor to edit Domino Style Sheet Resources
- Import and export style sheets into/out of Domino applications
- Add Style Sheet Resources to an XPage
- Export styles from a control to a Style Sheet resource (CSS file)
- Learn what themes are and how they can be used to globally alter an application
- Use the provided Themes in an application
- Select a theme to be used in an application
- Create a new theme to reference a specified style sheet
- Use a theme to apply a style to all XPage controls such as all the Label controls
Module 6 - JavaScript: The Language of XPages
JavaScript is the programming language of XPages. The events for most XPage controls can be both client-side and server-side JavaScript. Server-side JavaScript can also be used for computing the value of most of the properties on controls on an XPage. Server-side JavaScript code has full access to Domino data either in the current application or other applications via the Domino Object Model or @Functions. This module will explore the back-end Domino Classes and introduce how to access the Domino objects using server-side JavaScript on an XPage. Creating and using script libraries for storing reusable code in an application is covered in this module. The implementation of AJAX functionality to support type ahead and partial page refresh of an XPage is also covered. Finally, this module covers how to configure and use the Server-side JavaScript Debugger included in Domino Designer 9.
- Use client-side JavaScript for events on XPage controls
- Learn how to write client-side JavaScript to access XPage controls
- Use server-side JavaScript.for events on XPage controls
- Use sever-side JavaScript to get and set the values in controls on an XPage
- Use Global Objects and Global Functions in server-side JavaScript
- Use Scoped Variables to store data, such as the application scope, session, scope, request scope and view scope variables
- Debug server-side JavaScript using either the log file or using a Computed Field control
- Write server-side JavaScript to get full access (security permitting) to Domino applications via the Domino Object Model or @Functions
- The Domino @Functions
- Using @DbColumn and @DbLookup in Server-side JavaScript
- Dynamically hide XPage controls
- Use the Domino Object Model in server-side JavaScript such as the NotesSession, NotesDatabase, NotesView and NotesDocument classes
- The XSP Library classes that support XPage development
- Create and use client-side and server-side JavaScript libraries to store reusable code
- Use the Dojo library on an XPage
- Implement the type ahead and partial page refresh features of the included AJAX functionality
- Configure and use the SSJS Debugger included in Domino Designer
Module 7 - Advanced Techniques
The XPage basics including how to display a Domino view and how to link the view to Domino documents have already been covered. XPages are very powerful and can do much more than that. This module will cover some examples of how to harness the full power of XPages in a Domino application. These advanced techniques will be very practical to a Domino developer and will also provide some ideas on how to move even beyond these techniques and take advantage of the power of XPages for your specific needs. Techniques that were once either not possible or very difficult to perform in standard Domino development are accomplished quite simply due to the underlying key difference in XPages; the separation between the presentation and the data source. This module will show how to exploit this key difference by learning how to combine a view and document on the same XPage, have multiple data sources per page, and effectively display categorized and response-only views for example. Using the ACL property to refine access within the XPages application as well as several other advanced techniques and XPage related properties will be covered in this module. Finally, this module provides an introduction to Source Control and shows how the Mercurial tool is used in Designer.
- Add a dynamic view filter to a View control on an XPage
- Display data from multiple data sources on an XPage
- Link a view and form on the same XPage together so the document details are displayed when a user clicks on a document in the view
- Create dynamic tables using a Repeat control to display information from a Domino view
- Join together information from two different Domino views in one view control
- Use a Repeat control to display the contents of a multi-value field
- Write, compile, and execute Java code from an XPage
- Implement advanced techniques for displaying Domino views on an XPage such as categorized views and displaying a responses only column in a view
- Compute the values in a view column of a view control
- Explore the relationship between the Domino form design and an XPage
- Use the 'Run form validation' property on the XPage to implement Domino field formulas
- Implement "Authors" and "Readers" names fields on an XPage
- Use the XPage events to take the place of the Domino WebQuerySave and WebQueryOpen agents
- The XPage server and application properties , as well as several other advanced properties that affect XPage development.
- Add an XPage as a component in a composite application
- Add the ACL property to an XPage, Custom Control, Include Page or Panel to refine access within the application
- Introduce and demonstrate the use of source control in Domino Designer using the Mercurial source control tool
Module 8 - Building Custom Controls
Custom Controls provide the same functionality for XPages as subforms do for Domino forms. Custom Controls can be used to group common elements and controls on a "subXPage", perhaps to create a common header or footer. The Custom Control can then be added to other XPages in the same application. A Custom Control can also use properties that can be defined when the Custom Control is used on an XPage. A Custom Control can also have an "editable area" where content can be added once the control is used on an XPage. The use of these properties and editable areas allow the custom control to be fine-tuned for that particular XPage it is used on. This module will cover how to create and use your own custom controls, and how to add editable areas to a Custom Control.
- Create Custom Controls and use them in XPage design
- Set up configurable properties on a Custom Control
- Define the value for a Custom Control property after it is used on an XPage
- Add Editable areas to a Custom Control
Module 9 - Additional XPages Topics
This module covers additional XPages topics to help prepare for the Test LOT- 409: IBM Notes and Domino 9.0 Social Edition Application Development A and Test LOT- 410: IBM Notes and Domino 9.0 Social Edition Application Development B IBM Certification Exams. Some of these topics are covered at an introductory level in this module and are covered in greater detail in the XPages Development 2 course.
Module 10 - Additional Exam Topics
This module covers additional topics to help prepare for the Test LOT- 409: IBM Notes and Domino 9.0 Social Edition Application Development A and Test LOT- 410: IBM Notes and Domino 9.0 Social Edition Application Development B IBM Certification exams. Some of these topics are covered at an introductory level in this module and are covered in greater detail in other TLCC courses.
|