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 8: 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 Course goals



In this course, you will learn how to: 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.
Lotus Training Audience

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.
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 duration

4 days

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 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
      Global variables
      Exercise: Global 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
      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
      Split
      Join/Implode
      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
      Replace
      Determine the number of elements in an array
      Remove blank elements
      ArrayUnique
      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
      Lists

    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
      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
      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
      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 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
      Resources

    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

 
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