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


Contact Us   -   Why Choose Wintrac   -   Clients    

Courses
ADA
Adobe
Agile
AJAX
Android
Apache
AutoCAD
Big Data
Business Analysis
Business Intelligence
Business Objects
Business Skills
C++ programming
Cisco
Citrix
Cloud Computing
COBOL
Cognos
ColdFusion
COM/COM+
CompTIA
CORBA
CRM
Crystal Reports
Datawarehousing
DB2
Desktop Application Software
DNS
Embedded Systems
Google Web Toolkit (GWT)
IPhone
ITIL
Java
JBoss
LDAP
Leadership Development
Lotus
Machine learning/AI
Macintosh
Mainframe programming
Microsoft technologies
Mobile
MultiMedia and design
.NET
NetApp
Networking
New Manager Development
Object oriented analysis and design
OpenVMS
Oracle
Oracle VM
Perl
PHP
PowerBuilder
Professional Soft Skills Workshops
Project Management
Rational
Ruby
Sales Performance
SAP
SAS
Security
SharePoint
SOA
Software quality and tools
SQL Server
Sybase
Symantec
Telecommunications
Teradata
Tivoli
Tomcat
Unix/Linux/Solaris/AIX/
HP-UX
Visual Basic
Visual Foxpro
VMware
Web Development
WebLogic
WebSphere
Websphere MQ (MQSeries)
Windows programming
XML
XML Web Services
Other
Lotus Domino Designer 7: 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 to 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, and Windows Management Instrumentation via COM to use their properties and methods.
Lotus Training Audience

This course is designed for Notes programmers well versed in using Domino Designer 7. It assumes that you have:
  • extensive experience using Notes 7
  • thorough knowledge of the Domino Designer 7 development environment, including Form and View design
  • mastered the concepts covered in the Domino Designer 7: 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 7 training courses. Follow these paths to master all aspects of developing applications using Domino Designer:



Domino Designer 7: 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 7 Administrators and Developers.
  • Specialize in programming Notes applications to respond to built-in user interface features, Domino Designer 7: Special Notes Features.
  • Convert an application written for Notes clients to be used in browsers, Domino Designer 7: Basic Browser Applications.
  • Provide data to cutting-edge Web applications, Domino Designer 7: 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 7: Formula Language.
  • Develop sophisticated applications and Agents with LotusScript in Domino Designer 7: LotusScript.
  • Add powerful client-side scripting to browser applications in Domino Designer 7: JavaScript.
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.

Lotus Training Course outline

Topic 1: The Place of 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 can NOT do
  • Limits and performance
  • Other resources
Topic 2: 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
  • InputBox
  • Variables
  • Declare variables
  • Advantages of explicit declaration
  • Public variables
  • Exercise: Public variables
  • Constants
  • 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
  • Breaking 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
  • Specific error handling
  • Reverse engineer Err codes
  • Error cases
  • Exercise: Error handling
  • Multiple error handlers
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 7 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
  • Hunting 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
  • 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 constant
  • Example: Stop a Form from closing
  • 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
  • Split
  • Join/Implode
  • Read single array element value
  • Iteratively read array elements
  • Find an array element
  • Replace values in an array
  • Replace
  • Determine the number of elements in an array
  • Remove blank elements
  • ArrayUnique
  • Sort array
  • 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"
  • Challenge Exercise II: System inventory
  • Arrays and performance
  • Lists
Topic 16: Date-Time Operations
  • How time is stored
  • 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
  • Objects you can add to Rich Text item
  • Append text
  • Append spacing
  • Append style
  • Best practice: Style arrays and subs
  • Append doclink
  • Exercise: Formatted Rich Text
  • Append 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
  • Reload document to show Rich Text
  • Validate Rich Text
  • 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
  • Two collection 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: NotesView 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: Criteria-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 Search
  • Change a View Selection Formula
  • Search method performance
  • Exercise: Search summary
  • Solution: Search summary
  • Switch search methods on-the-fly
  • Domain Search
  • Code the FTDomainSearch method
Topic 21: Unprocessed Documents
  • Unprocessed documents and user interaction
  • Efficient processing by Agents
  • Unprocessed flag and Agents
  • Unprocessed search accuracy
  • Exercise: Unprocessed 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
  • Put document in Folder (the easy way)
  • Exercise: Put documents in Folder
  • Remove document(s) from Folder
  • Remove 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
  • 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
  • Lookups
  • Exercise: Using @Functions
  • Performance implications
Topic 26: Dialog Boxes
  • OpenFileDialog
  • SaveFileDialog
  • Prompt
  • Choose Database dialog box
  • PickListCollection
  • PickListStrings
  • Exercise: PickListStrings
  • Free Time dialogs
  • Folder dialog
  • DialogBox
  • 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
Topic 28: Profile Documents
  • What Profile documents are used for
  • The nature of Profile documents
  • 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
  • Trigger
  • Target
  • 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 queues
  • Usage guidelines
Topic 32: Agent Debugging, Logging, and Profiling
  • Remote LotusScript Debugger
  • Domino Server Log
  • Private Agent log
  • Custom Agent Log
  • Agent performance and Agent Profiling
  • DDM Application Probes
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
  • Resources
Topic 36: Use Other Product Objects
  • Component Object Model (COM)
  • Instantiate product object
  • Start and stop an application
  • 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
  • Example 8: Create 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

 
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