Email Us   Phone : 503-259-0312   
  Home    |    Instructor-led Training    |    Online Training     

Contact Us   -   Why Choose Wintrac   -   Clients    

Big Data
Business Analysis
Business Intelligence
Business Objects
Business Skills
C/C++/Go programming
Cloud Computing
Crystal Reports
Data Science
Desktop Application Software
Embedded Systems
Google Web Toolkit (GWT)
Leadership Development
Machine learning/AI
Mainframe programming
Microsoft technologies
MultiMedia and design
New Manager Development
Object oriented analysis and design
Oracle VM
Professional Soft Skills Workshops
Project Management
Sales Performance
Software quality and tools
SQL Server
Visual Basic
Visual Foxpro
Web Development
Websphere MQ (MQSeries)
Windows programming
XML Web Services
Lotus Domino Designer 8.5.x: LotusScript
Lotus Training Overview

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.

Lotus Training Learning Objectives

In this course, you will learn 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, Windows Management Instrumentation, and Lotus Symphony to use their properties and methods.
Lotus Training Audience

This course is designed for Notes programmers well versed in using Domino Designer 8.5.x. It assumes that you have:
  • extensive experience using Notes 8.5.x
  • thorough knowledge of the Domino Designer 8.5.x development environment, including Form and View design
  • mastered the concepts covered in the Domino Designer: Classic 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 training courses offered by us.

Lotus Training Course duration

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.

Lotus Training Course outline

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 Event Handlers
  • Event-driven language
  • Enter LotusScript code using classic LotusScript Editor
  • Automatic code completion
  • Programmers Pane properties
  • Print code
  • Syntax errors
  • Compile and test the code
  • Exercise: Create button event script
  • Eclipse-based LotusScript Editor
  • What is the sequence of events?
  • Exercise: Experience the event model
  • What happened? Create document event handlers
  • 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
  • Script Debugger
  • Find errors
  • Debugger buttons
  • Debugger tabs
  • Exercise: Use the Debugger
  • Exercise: Breakpoints
  • Persistent breakpoints
  • Debugging with Msgbox and Print
Topic 4: Language Fundamentals
  • Basic language rules
  • Remark code
  • Variables
  • Declare variables
  • Advantages of explicit declaration
  • Constants
  • Statements and functions
  • MessageBox parameters and return values
  • How Designer Help helps
  • InputBox
  • Exercise: Experience LotusScript functions
  • String functions
  • Math functions
  • Date functions
  • Data type conversion
  • Boolean operators
  • Global variables and scope
  • Exercise: Global variables
  • Code branching based on platform
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
  • Containment hierarchy/sequence
  • Object reference variables
  • Best practice: Use generic object names
  • Access current database using back-end methods
  • Best practice: Use constants when practical
  • Use Domino Designer 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
  • Environ$ function
Topic 10: NotesDatabase Object Operations
  • Paths to instantiate NotesDatabase
  • Select and open database
  • Create a new NotesDatabase object
  • Is the database really open?
  • Exercise: This database Info
  • Exercise: Parts database Info
  • Iterate notes\data folder 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 design template
  • ACL of new database from CreateFromTemplate
  • Delete database
  • Case Study
Topic 11: NotesDocument 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 1: Set Continue to stop a Form from closing
  • Example 2: Set Continue to require Action Button clicks
  • Example 3: Set Continue to stop deleting documents from a folder
  • Example 4: Set Continue to stop users from pasting documents
Topic 15: Multi-Value Items and Arrays
  • Array basics
  • Declare a static array
  • Assign values to an array
  • Read single array element value
  • Determine the number of elements in an array
  • Iteratively read array elements
  • Examples of object properties returning an array of values
  • Test if array is valid and not empty
  • Find an array element
  • Replace values in an array
  • Replace
  • Remove blank elements
  • ArrayUnique
  • Split
  • Join/Implode
  • 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 value 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
  • Lists
  • User-defined data type
Topic 16: Date-Time Operations
  • How date/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: Collection of Document Objects
  • Work on existing document(s)
  • NotesDocumentCollection object
  • Security issues
  • Shifting collections and error trapping
  • GetNextDocument syntax
  • Exercise: Loop through a collection
  • Solution: Loop through a collection
  • Create an empty collection
  • Add NotesDocument object to a collection
  • Remove NotesDocument object from a collection
  • Manipulate a collection
  • Batch changes to documents in a collection
  • Security is enforced with StampAll and RemoveAll
  • Sort a collection
  • Build a collection from Note objects
  • Collections and performance
Topic 19: View-Based Document Object Collections
  • NotesView object
  • Exercise: Loop through NotesView
  • Solution: Loop through NotesView
  • Resort the NotesView collection
  • 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 descendant documents
  • Iterate all levels of a document hierarchy
  • Sibling documents
  • Access a documents parent document
  • NotesViewEntryCollection object
  • EntryCount property
  • GetEntryByKey and GetAllEntriesByKey
  • NotesViewEntry and NotesDocument objects
  • Exercise: Status summary
  • Solution: Status summary
  • NotesViewNavigator object
  • Other ways to create a NotesViewNavigator
  • Example: CreateViewNavFromDescendants
Topic 20: Search-Based Document Collections
  • Collection from GetModifiedDocuments method
  • Create collection using Full Text Search
  • The Full Text Search query
  • Full Text Search using [FIELD]
  • Full Text Search for special items
  • Full Text Search options
  • Use the Full Text Search results
  • About the accuracy of Full Text Search
  • Refine an existing collection using FTSearch method
  • Exercise: FTSearch Summary
  • Solution: FTSearch summary
  • Create collection using Search method
  • 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
  • Agents and unprocessed documents
  • Unprocessed flag and Agents
  • Unprocessed search accuracy
  • Exercise: Unprocessed documents
  • Documents highlighted and/or selected in a View
  • "Source" and Database and View event handlers
  • Unread documents
Topic 22: Existing Document Operations
  • How to instantiate an existing NotesDocument object
  • Make a copy of the current document
  • Delete a document
  • Remove documents from the database
  • Security issues
  • Exercise: Archive selected documents
  • Test for locked document
  • Lock document
  • Does the document really need to be saved?
  • Soft deletions
  • Delete document open in Read mode
  • IsValid document? IsDeleted document?
  • 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
  • Exercise: Newsletter report
  • Case study: Custom search Form
  • Optional exercise: Order report
  • FormatDocument method
Topic 24: Mail Messages
  • Send document
  • Example Agent
  • Send method parameters
  • Source database
  • Read the Directory for user mail information
  • NotesDirectoryNavigator
  • Change the apparent sender name from Notes
  • Change the apparent sender name from an Agent
  • Prevent Agent mail "ping-pong"
  • Exercise: Send mal 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
  • Why evaluate @Functions in LotusScript?
  • Which @Functions cannot be used?
  • Evaluate syntax
  • Examples
  • @Functions outside of object context
  • Sum an array
  • Lookups
  • Exercise: Using @Functions
  • Performance implications
Topic 26: Dialog Boxes
  • OpenFileDialog
  • SaveFileDialog
  • Prompt
  • Remove Docs from Folder using Prompt
  • Choose Database dialog box
  • PickListCollection
  • PickListStrings
  • Exercise: PickListStrings
  • Free Time dialogs
  • Notes Folder dialog
  • DialogBox
  • From where you can call the DialogBox method
  • Display status information to user
  • Case study: Bring the data here
Topic 27: Database Access Control List
  • User name review
  • Best practices
  • Minimum database access requirements
  • Find a known ACL entry level
  • 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
  • -Default- special handling
  • 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 server administrator, and company policy
  • Groups in the ACL
Topic 28: Profile Documents
  • Examples of Profile documents
  • The nature of Profile documents
  • Profile document security and replication
  • Create Profile document
  • Back-end method to create and access Profile document
  • Read Profile document Fields
  • List all Profile documents
  • Exercise: Profile document to store DDLS8 Parts server and filepath
  • Delete Profile document
  • Profile Document Management tool
  • Technotes related to Profile documents
Topic 29: Custom 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
  • Create a LotusScript Library
  • 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
  • Test the Widget custom class
  • 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 a new Agent
  • Trigger (Basics tab)
  • Target (Basics tab)
  • Document selection tab
  • Selecting unprocessed documents
  • Before new mail arrives trigger (Basics tab)
  • Agent security (Security tab)
  • Handling UI method errors in Agents
  • DelayUpdates property for Agents
  • Pass arguments at run time
  • Work queue architecture
  • Agent best practices
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
  • Print 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
  • Notes converts to MIME in email messages
  • Send MIME/HTML message
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 C API: Close any Notes window
  • Notes C API: Run file from Notes
  • Other DLL examples
  • Resources
Topic 36: Use Other Product Objects
  • Component Object Model (COM)
  • Instantiate product 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 handler
  • Troubleshoot OLE problems
  • Example 9: Operate on a detached attachment
  • Windows Script Host (WSH)
  • Windows Management Instrumentation (WMI)
  • Lotus Symphony and COM/OLE
  • IBM Lotus Symphony 3.0 Toolkit
  • Internet Explorer object
  • COM access to Notes objects
  • Buy versus build

About us
Contact us
Careers at Wintrac
Our Clients
Why Wintrac

Register for a free training CD-ROM drawing
Refer a client or instructor and earn $$$

Wintrac Inc.
16523 SW McGwire Ct.
Beaverton OR 97007
© Wintrac, Inc. All rights reserved.                                                                               Site Map   |   Terms of Use   |   Privacy Policy