Lotus Domino Designer 8: LotusScript

Course Code: DDLS8
Product: Lotus Notes/Domino R8.0.1
Duration: 4 days
Topics/Pages: 36 topics / 574 pages
Price (US dollars):
$85 per user


LotusScript is a BASIC derivative that uses many of the same statements and function names, so most developers will find it easy to understand and use without too much relearning.
While this course teaches the basics of LotusScript, its primary emphasis is not on the language itself, but rather on how to use it to operate on Notes database, view, document, field, and ACL objects. With this knowledge, you will be able to develop powerful custom applications and extend the standard templates such as Mail or Discussion.

Course goals

This course will teach you how to:

  • use fundamental LotusScript language elements as you program and debug applications using Domino Designer
  • use LotusScript in various Notes events to operate on objects in the Domino Object Model
  • configure client, server, database, and document security mechanisms to allow LotusScript to operate
  • reconcile LotusScript and Notes data types and validate user input
  • design error handling routines to gracefully recover from runtime errors
  • operate on new and existing documents as well as on collections of documents
  • use messaging to send email, documents, and newsletters
  • operate on the database ACL and develop an alternative user interface so users can more easily administer database security
  • interact with users with both the primitive LotusScript and sophisticated Notes dialog boxes
  • use Profile documents to store application and user-specific configuration settings
  • develop custom procedures and classes and use Script Libraries to store and share commonly used procedures across design elements and applications
  • develop server-based Agents that use LotusScript and Notes objects to process documents
  • debug Agents using the Remote LotusScript Debugger, report errors to a log file, profile Agent performance, and work with your server administrator to develop application probes to monitor ongoing Agent performance
  • operate on file system based text files
  • generate MIME content that can be used to send formatted emails with intact HTML
  • parse XML files to extract element data and attributes
  • run procedures stored in Windows, Notes, and other product DLLs
  • instantiate objects from other products such as Office applications, Windows Script Host, and Windows Management Instrumentation via COM to use their properties and methods.


This course is designed for Notes programmers well versed in using Domino Designer 8. It assumes that you have:

  • extensive experience using Notes 8
  • thorough knowledge of the Domino Designer 8 development environment, including Form and View design
  • mastered the concepts covered in the Domino Designer 8: Basic Notes Applications course.

The course does not review any aspects of the non-LotusScript specific development environment such as how to design forms or views.

Though not required, experience in any event-driven or structured programming language is helpful in understanding LotusScript. If you have used LotusScript in other Lotus applications or have built applications using Microsoft® Visual Basic™, you will find that this course won't be repetitive as it focuses mostly on Notes objects.

This course is part of a series of Domino Designer 8 training courses. Follow these paths to master all aspects of developing applications using Domino Designer.

Domino Designer 8: Basic Notes Applications provides the base knowledge for this additional training:

Client Track

  • Configure Domino to use DB2 as a database engine and build applications that access relational data, DB2 for Domino 8 Administrators and Developers.
  • Specialize in programming Notes applications to respond to built-in user interface features, Domino Designer 8: Special Notes Features.
  • Convert an application written for Notes clients to be used in browsers, Domino Designer 8: Basic Browser Applications.
  • Provide data to cutting-edge Web applications, Domino Designer 8: Web Agents and Web Services.

Language Track. These languages apply to both Notes and browser clients:

  • Learn sophisticated application techniques that fully exploit the formula language in Domino Designer 8: Formula Language.
  • Develop sophisticated applications and Agents with LotusScript in Domino Designer 8: LotusScript.
  • Add powerful client-side scripting to browser applications in Domino Designer 8: JavaScript.


This course is sold as a 4-day course, but it is unlikely that you can finish all the topics in four days. To finish in four days, it is recommended that you defer the last few topics for self-study. Many training centers allocate five days to cover this material.

Course design

This is a lecture/lab course in which you will closely examine demonstration code and create additional code. You will immediately apply the concepts and techniques as you work in your own project database.

This is not an introductory programming course. Its emphasis is on how to use LotusScript to manipulate Notes objects. All major concepts are reinforced with examples and exercises, during which you will code and debug LotusScript. From this experience you will have the necessary skills to build sophisticated applications.

All code fragments are labeled to make talking about them and reusing them in exercises easier. The intent in labeling them is also to help build a sense of modularity, purpose, and a way of "thinking" about LotusScript.


Topic 1: LotusScript in Notes and Domino 

What is LotusScript?
Advantages of LotusScript for Notes/Domino
When to use LotusScript
Where the code runs
LotusScript respects security
What LotusScript cannot do
Limits and performance
Other resources

Topic 2: Lotus Notes Events 

Event-driven language
Enter LotusScript code
Automatic code completion
Programmers Pane properties
Print code
Syntax errors
Compile and test the code
Exercise: Create button event script
What is the sequence of events?
Exercise: Experience the event model
What happened? Create document events
Query what? Post what?
Recalculate document event
Save document event
Close document event
Switch modes events
Read document events
Agent events
Database events
View events
Field events

Topic 3: Debugging 

Script errors
Remark code
Script Debugger
Find errors
Debugger Buttons
Debugger tabs
Exercise: Use the Debugger
Exercise: Break points
Persistent breakpoints
Debugging with Msgbox and Print

Topic 4: Language Fundamentals 

Basic language rules
MessageBox parameters and return values
Declare variables
Advantages of explicit declaration
Global variables
Exercise: Global variables
User-defined data type
Statements and functions
Exercise: Experience LotusScript functions
String functions
Math functions
Date functions
Data type conversion
Boolean operators
How Designer Help helps
Platform considerations

Topic 5: Program Control Structures

Program structure
Experience control structures
Branching structures
Exercise: Branching structures
Looping structures
Looping performance
Code benchmarking
Exercise: Looping
How to exit a structure
Break out of an endless loop
Exercise: Exit a structure

Topic 6: User Input Validation and Error Handling 

Check for empty variable
Failure to exit loop
Check data type
Other data type tests
Exercise: User input validation
Error handler
Resume after error
Goto after error
Resume 0
Specific error number handling
Reverse engineer Err codes
Error cases
Exercise: Error handling
Multiple error handlers
Error handlers and the Debugger

Topic 7: Domino Object Model 

What is an object?
Object class properties and methods
Domino Object Model
Back-end vs. Front-end classes
Back-end object classes
Front-end object classes
How Designer Help helps

Topic 8: Notes Object Instantiation

Object instantiation steps
How to instantiate an object
Container objects
Object reference variables
Best practice: Use generic object names
Access current database using back-end methods
Best practice: Use constants
Use Domino Designer 8 Help
Exercise: Object containers
Access other databases using back-end methods
Access other database on server
Exercise: Instantiate object in another database
Best practice: Public declarations of Notes objects
Notes object properties
Read object property
Set object property
Chain/pipe references
"With" statement
Notes object methods
Run Notes object methods
Three types of methods
Exercise: Open method
LotusScript is not a keystroke macro language
Interact with users via front-end methods
Exercise: Open database for user
Delete object reference

Topic 9: NotesSession Object Operations 

Session properties
NotesName object class
NOTES.INI access
Data type assignment from environment
Exercise: Set environment

Topic 10: NotesDatabase Object Operations 

Paths to instantiate NotesDatabase
Select and open database
Ways to create a new NotesDatabase object
Is the database really open?
Open database on servers
Exercise: Database Info
Iterate \data to look for a database
NotesReplication class
Exercise: NotesReplication class
Open database for user in UI
Open a database by property
Error handling when opening databases
Exercise: Find database
Create non-replica database copy
Who can create a database?
Copy documents to new database
Exercise: Database Copy
Error handler review
Create replica copy
New database from template
ACL of new database from using template
Delete database
Case Study

Topic 11: New Document Object Operations 

New document (back-end)
Security issues with back-end methods
Document properties
Exercise: Create Document (back-end)
New document using Form (front-end)
Security issues with front-end methods
Exercise: Create NotesUIDocument object

Topic 12: NotesItem Object Operations 

Create a new item Option 1: Extended class syntax
Data type of a new item
Create a new item Option 2: NotesItem object New method
Item properties you can set
Create a new item Option 3: Document object method
Create a new item Option 4: AppendItemValue method
Read item values Option 1: Extended class syntax
Read item values Option 2: NotesItem object Values property
Read item values Option 3: Use GetItemValue method
Modify existing item values
Best practice: Be sure an item exists before using it
Access system fields
Read all items
Remove item
Exercise: Manipulate NotesItem objects
Challenge Exercise I: System Inventory
Objects required for Challenge Exercise
Pseudocode for Challenge Exercise

Topic 13: UI Object Classes

NotesUIWorkspace object
Close method
NotesUIDocument object
Instantiating the current UI document object
Front-end UI methods
Back-end to front-end interaction
Example of back-end to front-end interaction
NotesUIDocument limitations
Using the "Source" object reference variable
Instantiating container object
Exercise: Flip-Flop via back-end methods
Exercise: Flip-Flop via front-end methods
NotesUIView object
Refresh a View

Topic 14: Notes Data Validation 

Form translation and validation
Check empty object
Example: Check empty object
Check for empty item (Field)
Example: Check for empty item (Field entry)
Accessing fields in a Form
Field focus
Simple Field validation
Exercise: Item validation
Compute with Form
Continue variable
Example setting Continue I: Stop a Form from closing
Example setting Continue II: Require Action Button clicks
Stop users from deleting documents in folders
Stop users from pasting documents

Topic 15: Multi-Value Items and Arrays 

Array basics
How to declare an array
Assign values to an array
Read single array element value
Iteratively read array elements
Examples of object properties returning an array of values
Find an array element
Replace values in an array
Determine the number of elements in an array
Remove blank elements
Dynamically sized array
Create copy of an array
Erase array values
Exercise: Dynamic array
Append one array to another array
Multi- dimension arrays
Items and multi-value Fields
Variable assignment
Testing equivalence
Read an array of strings or array of objects?
Get multi-value Field in current document
Set multi-value Field in current document
Append to existing multi-value Field
Exercise: Translate a multi-value Field
More on "Item" versus "Field"
Sort array
Challenge Exercise II: System inventory
Arrays and performance

Topic 16: Date-Time Operations 

How time is handled
Date and time in LotusScript
NotesDateTime object
Date/Time parameter format
NotesInternational object

Topic 17: RichTextItem Object Operations 

Rich Text programmatic issues
Instantiate NotesRichTextItem object
Accessing existing NotesRichTextItem objects
Things you can add to Rich Text item
Append text
Append spacing
Append character styles
Best practice: Style arrays and subs
Append doclink
Exercise: Formatted Rich Text
Append file attachment
Detach attachment
Append another NotesRichTextItem
Abstract text
Navigate through the elements in a Rich Text item
Insert object into existing Rich Text
Example: Append and populate table
Reopen document to show Rich Text
NotesUIDocument techniques to work with Rich Text Field
Validate Rich Text entry
NotesRichTextItem object Update and Compact methods
Challenge Exercise III: System inventory
RTF versus MIME

Topic 18: Collections of Document Objects 

Work on existing document(s)
NotesDocumentCollection object
Security issue
GetNextDocument requirements
Exercise: Loop through NotesDocumentCollection
Solution: Loop through NotesDocumentCollection
Add or remove documents from a collection
AddDocument and DeleteDocument method tricks
Bulk changes to document collections
Security issues with StampAll and RemoveAll
Other collections of document objects
Sort a collection
Collections and performance

Topic 19: View-Based Document Object Collections 

NotesView object
Exercise: Loop through NotesView
Solution: Loop through NotesView
NotesDocument object ColumnValues property
Primary key and View concerns
Get a document or document collection by View key
Example: Build a collection by View key
Process descendent documents
Iterate all levels of a document hierarchy
Sibling documents
Access a documents parent document
View.EntryCount property
NotesViewEntryCollection object
NotesViewEntry and NotesDocument objects
Exercise: Status summary
Solution: Status summary
NotesViewNavigator object

Topic 20: Search-Based Document Collections 

Collection from GetModifiedDocuments method
Collection by Full Text Search
The query
Search items using [FIELD]
Search on special items
Full Text Search options
Use the results
About the accuracy of Full Text Search
Refine an existing collection
Exercise: FTSearch Summary
Solution: FTSearch summary
Collection by ordinary Search
Change a View Selection Formula
Exercise: Search summary
Solution: Search summary
Search method performance
Switch search methods on-the-fly
Domain Search
Code the FTDomainSearch method

Topic 21: Unprocessed, Selected, Unread Documents

Unprocessed documents
Unprocessed documents and user interaction
Efficient processing by Agents
Unprocessed flag and Agents
Unprocessed search accuracy
Exercise: Unprocessed documents
Documents highlighted and/or selected in a View
Unread documents

Topic 22: Existing Document Object Operations 

Make a copy of the current document
Delete a document
Security issues
Exercise: Archive selected documents
Delete open document
Test for locked document
Lock document
Does the document really need to be saved?
IsDeleted and soft deletes
IsValid document? IsDeleted document?
Is document open in the UI?
Open user-selected document
Put document in Folder (back-end)
Put document in Folder (front-end)
Exercise: Put document(s) in Folder
Remove document(s) from Folder
Remove all Folders
Remove only personal Folders
Make Response document

Topic 23: Newsletter Object 

NotesNewsletter object
Create newsletter object
Exercise: Newsletter report
Case study: Custom search Form
Optional exercise: Order report
FormatDocument method

Topic 24: Messaging 

Send document
Example Agent
Send method parameters
Source database
Read the Directory for user mail information
Change the apparent sender name from Notes
Change the apparent sender name from an Agent
Prevent Agent mail "ping-pong"
Exercise: Send message
Optional properties and Fields
Exercise: Status Checker Agent
Solution: Status Checker Agent
Challenge Exercise IV: System inventory
Programmatically send Sametime instant messages

Topic 25: Evaluate @Functions 

Which @Functions cannot be used?
Why evaluate @Functions in LotusScript?
Evaluate syntax
Sum two Fields
String functions
Uppercase Field
@Functions outside of object context
Sum an array
Exercise: Using @Functions
Performance implications

Topic 26: Dialog Boxes 

Choose Database dialog box
Exercise: PickListStrings
Free Time dialogs
Folder dialog
From where you can call the DialogBox method
Status information
Case study: Bring the data here

Topic 27: Database Access Control List 

Minimum access requirements
Best practices
Find a known ACL entry level
Name storage in the ACL
ACL level constants
Iterate ACL entries
Other ACL permissions
Resolve group or Organization wildcard name
Why control the ACL with LotusScript?
Add an ACL entry
When to save ACL changes
-Default- special handling
Exercise: Set ACL
Change the level of an entry
Rename an entry
Delete an entry
Exercise: ACL control
Set permissions
Set entry type
Add a Role
Associate an entry with a Role
Role resolution
Disassociate entry from Role
Rename Role
Remove a Role
ACL and replication
ACL, your Domino administrator, and company policy

Topic 28: Profile Documents 

What Profile documents are used for
The nature of Profile documents
Profile document security and replication
Create Profile document
Back-end method to access Profile document
Read profile Fields
List Profile documents
Delete Profile document

Topic 29: Procedures and Script Libraries 

Advantages of using procedures
How/where to define procedures
Function procedures
Call a function
Single function argument
Pass an array as an argument
Multiple function arguments
Example: ConvertTemp function
Example: ReplaceSubstring function
Exercise: Value translation
Exit a procedure
Sub procedures
Example: Sub procedure
Pass argument by reference
Pass argument by value
Script Libraries
Use "LibraryName" statement in Options
Exercise: Use a Script Library
Resource strings
Script Library tips
Recursion example: Process all child documents
Recursion example: Find root parent document
Recompile all LotusScript
%Include LSS file

Topic 30: Custom Classes 

Custom classes
Derived classes (inheritance)
Memory management
Example: Custom helper class
Advantages of object-oriented programming
Learn more about custom classes
.LSO files
.LSX files

Topic 31: Server-Based Agents 

Create new Agent
Document selection "event"
Unprocessed documents
Before New Mail Arrives trigger
Agent security
Handling UI method errors in Agents
DelayUpdates property for Agents
Pass arguments at run time
Work queue architecture
Usage guidelines

Topic 32: Agent Logging, Profiling, and Debugging 

Domino Server Log
Private Agent log
Custom Agent Log
Agent performance and Agent Profiling
DDM Application Probes
Remote LotusScript Debugger

Topic 33: Text File Operations

Write to a text file (Output)
Read lines from a text file (Input)
Read performance
Delete a file
Example: List Databases to File
Exercise: Append to text file
Export records to text file
Easy comma delimited export
Import records from text file
NotesStream class
Open, write to, and close NotesStream object
List databases example
MIME in email messages
Agents and MIME/HTML

Topic 34: XML Processing 

What wont be covered
NotesDOMParser and NotesDOMDocumentNode classes
Example XML file
Walk DOM Tree
Exercise: Correlate XML file to walkTree report
Create Notes documents from XML
Open a NotesStream to a URL

Topic 35: Call DLL Procedures 

Declare DLL procedure
Call the DLL Procedure
Caveats and tips
Win API: GetFolderName
Win API: Read/Write INI file
Win API: Get registry value
Notes API: Close any Notes window
Notes API: Run file from Notes
Other DLL examples

Topic 36: Use Other Product Objects 

Component Object Model (COM)
Instantiate Excel objects
Start and stop an application
Product object hierarchy
Access the object methods and properties
Where to find object data files
Example 1: Create Excel object from file
Example 2: Create new Excel object and set formula
Example 3: Create new Excel chart object
Example 4: Export View to Excel
Example 5: Create new Word object
Example 6: Create new Word object (labels)
Compound Document Container
Example 7: Work with embedded object
Notes and OLE
Example 8: Create OLE object in PostOpen event
Troubleshoot OLE problems
Example 9: Operate on attachment
Windows Script Host (WSH)
Windows Management Instrumentation (WMI)
COM access to Notes objects
Buy versus build
Lotus Symphony