10 everyday LotusScript tips

Error trapping tests a particular condition when running a program. If the program runs into an error, it will then execute a corresponding routine to fix the error. This should always be done. Error handling is not a joke -- it should always be handled in a serious manner and should always be mandatory.

There are two ways to go about this:

• Use a single error handler at the top of your LotusScript code. It is simple to implement, but at times difficult to keep in context.

• Implement your error handler at the function level. It's a little bit more work, but it's also much more granular.

While it may seem a bit paranoid, you should practice using defensive LotusScript coding -- it will save you time in the long run. Always assume the worst and check all inputs on every function. It doesn't usually affect performance, but it is a good failsafe.

Here is a good example of defensive LotusScript coding in a typical function.

When creating commercial applications, it's a very good idea to hide your code. But, you may be asking how. There are actually two ways you can go about it:

• Create a template and click on "hide design." This is easy to do, but it may end up allowing form customization.

• You could also remove your LotusScript source code from your script libraries. Use the NotesNoteCollection command to find your script design document. Then replace the "$ScriptLib" with a String -- "Hello." This is not the easiest way to go about this process, but your other design elements can be modified as well. (Do not do this on your development copy!)

...

You should never store date/time values as strings. It is always good practice to use NotesDateTime structures instead and save them.

You might say, sure, but why? Well, you never know how the client will interpret dates. Is it dd/mm/yyyy or mm/dd/yyyy? It also means that views will be able to sort on dates.

Trust me, this is a good tip to practice. This issue comes up more often than you might think.

A good reason to consider using DXL as Transport stems from a situation where a customer wants to easily send back "log" documents. When this happens, you can use a LotusScript agent to:

• Pick up all selected documents.

• Create a memo with a rich-text field.

• Use DXL to store the documents in the rich-text field.

At the receiving end, this will:

• Unpack the mail message to a DXL stream.

• Construct new documents to store the data.

This way, you are transferring data without replication. Below is a sample code of this being implemented.

When using a wizard interface with your Lotus Notes client, there are a few steps you should follow:

• Create a form with a tabbed table.

• Set the tabs to "1," "2," "3," etc.

• Select "Switch Rows Programmatically."

• Set the "name" field to the name of the table; for example: "RequestTable."

• Create a variable on the form with $Name; for example: "$RequestTable."

• Have your "forward" and "back" buttons increment/decrement the variable.

There are two different ways you can go about consuming Web services. The first is quick and to accomplish it, you should follow these steps:

When developing with LotusScript, it is always a good idea to use classes. Here are some reasons why:

• Classes help to bundle data and code in one place.

• They decompose problems into "objects."

• They help to write smaller, more focused code.

• They help define and implement the internal data model.

• They aid reusability.

Classes have a good design methodology, which leads to Java. But everyone is not used to them and it may take time to sink in. Below you will see some code that implements classes.

The Evaluate command allows you to run @Functions within LotusScript. It is sometimes quicker and easier, as it allows you to use your favorite function in certain situations.

An example of it might be:

Don't overuse it though. Loads of LotusScript functions mimic @functions.

It is good practice to use trusted servers because scheduled agents cannot normally open databases on other servers.

The "trusted servers" field in a Lotus Domino R6 server document's security section allows servers to trust other servers. By doing this, it allows you to centralize "collection" agents. You also simplify your architecture and limit the number of agents you use. However, it does rely on a fast, reliable network infrastructure.

As a final note, make sure to never trust servers in another domain.