Significance of Study
Peer to Peer Journal Articles| Knowledge Based Topics in Database Management
Chapter 1
Lotus Notes is an application suite that includes the following components:
- calendaring and scheduling
- address book
- database
- web server
- programming
Unlike other application suites (like Microsoft Office) that split these pieces of functionality into separate products (like Outlook, Access, Front Page, etc.), Lotus Notes presents all of these components using a single front-end.
For many people, Lotus Notes is an e-mail system. While this is not necessarily it’s largest strength as a product, e-mail is probably the most recognizable component that it has. It has most or all of the features of the other popular e-mail products on the market, including calendaring and scheduling, and it uses standards-based mail protocols such as POP3 and SMTP. Because Notes has both a client and a server piece, users can use it to read and respond to e-mail, and administrators can use it as an entire e-mail environment.
For all practical purposes though, everything in Notes is a database. Individual users have their own e-mail databases, and different sets of users can share application databases that can display, add, or manipulate information. Besides data, a database can also contain modules of programming code that will perform background, scheduled, or on-demand tasks for a user.
The Lotus Notes client is a desktop application that organizes and displays databases on a user’s local workstation. The physical database files can be stored either on the workstation itself or on a server. A typical Notes client “workspace” will have icons for a handful of local databases as well as a number of databases that reside on one or several Notes servers. All of these icons can be grouped together, so that the distinction between local and remote data becomes very trivial.
The databases themselves can be highly customized to present the data that is associated with them. A Lotus Notes developer can design forms to display individual data records, and views to display whole sets of data. In some cases, the data that is displayed doesn’t have to come only from the database that you’re in — it can also come from one or more other Notes or non-Notes databases.
Because the programming layer is built-in to the Notes databases, a developer can embed code throughout the database design to automate certain actions or reactions without having to install or configure external programs or processes. This built-in programming layer also makes it possible to create workflow applications that interact very fluidly between both application databases and e-mail.
If all or some of your user base doesn’t want to use the Notes client, the capability to automatically display Notes databases on the web is available as well. Since version 4.5, the Notes server software has shipped with a web server component called “Domino”, which translates Notes data into web pages and serves them up as a web site. Internet programming technologies such as JavaScript and Java are native to Notes, so these can be easily incorporated into Notes databases and design elements (either on the web or on the client). The Domino web server can also be configured to interact with things such as IIS, Apache, and Java servlets and JSP pages, so you can enhance your Domino website using other (possibly pre-existing) technologies within your environment.
On a slightly more technical level, Notes/Domino provides a very granular security model that allows a developer to “lock down” access to all or parts of a database. In this way, you can combine private and public data within a single database or across a single server. While the security is normally administered through a corporate Notes address book, it can also tie in to the user accounts in an NT domain or any LDAP-aware directory service.
With all of this functionality, it may be hard to envision what Notes can actually do for you. Some examples of typical Notes applications are:
- e-mail (obviously)
- discussion forums
- document repositories
- expense approval systems
- web-based request systems
Using the capabilities of Notes to interact with other database systems and other web technologies, you could also use it as a client-based or web-based information portal that ties together a number of different data sources. Lotus Notes can be a stand-alone data repository, a front-end to numerous other data repositories, or many things in-between.
Chapter 2
At its most basic level, Lotus Notes is a database system. In fact, most Notes environments consist of a collection of databases that might interact with each other at some level.
Lotus Notes, however, is not a relational database system. A Notes database is a collection of unstructured data, combined with various design elements that allow you to access and manipulate that data.
Before you allow any pre-conceived notions or biases about relational versus non-relational data to cloud your opinion of Notes, please read through the explanation below.
By walking through the design of a basic Notes database, you can better understand how the data is organized and treated within Notes. Let’s say that we want to create a database that tracks information for a car club. To start, we would create a blank Notes database, and within that database we would create a Form to display some fields of data that relate to cars. For example, our Form might have fields called “CarMake” and “CarModel”.
A Form allows a user to view or manipulate the data fields of a given record in the database. As such, its format is quite customizable in terms of colors, fonts, and layout. However, the Form does not actually hold the data itself — it is simply a way to present the data.
Let’s say that we’ve created and saved a Form with the two fields described above. We’ll have to name the Form, so we’ll call it “Car Data”. If you want to imagine a Notes database as having an internal table that holds all of the data records in the database, the internal table for our new database would look something like this:
| Form | CarMake | CarModel |
If we wanted to start populating the internal table, we could actually start doing it now. Every time we opened our Form, entered data, and saved the form, we would be creating new data records in the table. In Notes terminology, a data record is a Document. If we created several new Documents using our “Car Data” Form, our internal table might start to look something like this:
| Form | CarMake | CarModel |
| Car Data | Ford | F-150 |
| Car Data | Honda | Civic |
| Car Data | Porsche | Boxster |
There are also several internal data fields (like the date the record/Document was created and the user who created it) associated with each Document, but the table above represents the data we can work with and change. As we added new Documents, they would be added to the internal table, and we could also edit or delete the Documents if we had access rights to do so.
Now say we want to add a field to track the color of the cars as well. To add a field to the internal database all we have to do is add a new field to the Form. We would open up the “Car Data” form, add a field called “CarColor”, and save the Form. Now our internal table would look like this:
| Form | CarMake | CarModel | CarColor |
| Car Data | Ford | F-150 | |
| Car Data | Honda | Civic | |
| Car Data | Porsche | Boxster |
If we have the proper access to the database, we could even edit the existing Documents to make the table look something like this:
| Form | CarMake | CarModel | CarColor |
| Car Data | Ford | F-150 | White |
| Car Data | Honda | Civic | Blue |
| Car Data | Porsche | Boxster | Red |
As we think more about the database, maybe we’ll want to also track information about the members of the car club. We’ll make a new Form called “Owner Info”, and add two new fields to the Form, “OwnerName” and “OwnerPhone”. After we’ve saved the new Form, the internal table will look like this:
| Form | CarMake | CarModel | CarColor | OwnerName | OwnerPhone |
| Car Data | Ford | F-150 | White | ||
| Car Data | Honda | Civic | Blue | ||
| Car Data | Porsche | Boxster | Red |
Notice how the new fields just get appended on to the end of the internal database. However, if we open the “Car Data” Form back up, we won’t see the new fields on the Form. Why? Because even though all the fields for all Forms are stored in a flat database, the individual Forms themselves only display whatever subset of fields that the database designer wants them to display.
If we create a couple of new Documents using the “Owner Info” Form, our internal table might now look similar to this:
| Form | CarMake | CarModel | CarColor | OwnerName | OwnerPhone |
| Car Data | Ford | F-150 | White | ||
| Car Data | Honda | Civic | Blue | ||
| Car Data | Porsche | Boxster | Red | ||
| Owner Info | John | 555-1212 | |||
| Owner Info | Steve | 555-9000 |
I know that all of the relational database programmers are writhing in pain looking at this table right now, so let’s cover a few bases. First of all, the data inside a Notes database isn’t structured exactly like this — notably, there isn’t all the white space you’re seeing above — but it’s good for the sake of diagramming the data for people who are used to looking at tables. It’s also going to help us make sense of some of the other concepts we’ll touch on below.
Second, there can be overlap between the fields of various Forms, so there’s nothing keeping us from adding an “OwnerName” field to the “Car Data” Form. In fact, you could do this as a way of tying together the “Car Data” information and the “Owner Info” information. The fields on a Form don’t just have to be placeholders for fields, they can be programmed as well. For example, your “OwnerName” field on the “Car Data” form could have a formula that simply looks up the owner names and allows the user to choose an existing owner. In SQL terms, this formula would essentially perform the query:
SELECT DISTINCT OwnerName FROM InternalTable WHERE Form = ‘Owner Info’;
If we did this, and edited the existing “Car Data” Documents, we’d have an internal table like this:
| Form | CarMake | CarModel | CarColor | OwnerName | OwnerPhone |
| Car Data | Ford | F-150 | White | Steve | |
| Car Data | Honda | Civic | Blue | John | |
| Car Data | Porsche | Boxster | Red | Steve | |
| Owner Info | John | 555-1212 | |||
| Owner Info | Steve | 555-9000 |
Of course, if you had a good relational database background, you’d probably use some sort of numeric OwnerID field instead of the OwnerName, but you get the idea. The point is that records/Documents can be tied together in this manner.
Another interesting aspect of the Notes data store is that the data fields are not strongly typed. In other words, even though you initially set up a field as a numeric field, you can later add text data to that field (if you modify your Form or add data programmatically). In this way the data fields are more like columns in a spreadsheet than columns in a table. In a spreadsheet, you might be able to store dates, numbers, text, and objects all in a single column. Notes is the same way. A field can even hold items such as file attachments or OLE links.
While all of this might seem like a terribly “loose” way to be managing data, it actually makes it much easier to develop and update an application. If you need new fields on a Form, you just add them. If you need a whole new Form with a new set of fields, you can just add that too. If you need to change a numeric field to a text field months after a database has been developed, you can just change it without having to [necessarily] worry about the old data. You don’t have to know anything about tables and data normalization and relational database theory, because Notes handles everything internally.
Anyway, now that you’ve started storing data in the internal table, you’ll want to start viewing it as well. In the relational database world, you’d normally write a query to filter and sort your information; in Notes terms, you create a View.
A View is a tabular presentation of a filtered subset of data in the internal table. You define not only the filter that you want to apply (like “all records that were created using the ‘Car Data’ form”), but also the individual fields that you want to display in columns, and the way that the data is categorized and sorted. You can even add programmatic columns to the View, to display conditional data, totals, sums, or many other manipulated versions of the data in the fields.
If you need to programmatically manipulate the data within the database, Notes provides a number of options for programmatic data access and modification. You can natively use @Functions (a macro language), LotusScript (very similar to Visual Basic or VBA), JavaScript (to a certain extent), and Java. All of these bits of code can be stored either directly on the Form or View design (associated with events, actions, or button clicks) or in modules called Agents or Script Libraries. An Agent is essentially a program inside the database that can be either called by the user or kicked off in an automated fashion. A Script Library is a collection of functions, routines, modules, and/or classes that can be globally modified and shared among various design elements in the database (including Forms, Views, and Agents).
In a lot of ways, a Notes database is similar to a Microsoft Access database. Everything is all in one file. The data is either stored in local tables or accessed from a remote server. You create Forms to display and modify the data. You use Views/Queries to sort and display the data. You can embed LotusScript/VBA within different elements of the database, and call those scripts in a variety of different ways.
You may have heard that Lotus Notes is also an e-mail system. It is. In fact, some people use it only as an e-mail system. However, if you think about what e-mail is, and how it is stored once it arrives on your local machine, e-mail is just a database. Every user has their own individual Notes e-mail database that has been customized for mail activities. Calendar and schedule? Another database. Address Books? Databases. Once you start having a database-centric view of the world, a lot of things can be looked at as being just another type of database, especially when you’re thinking in terms of a Notes database, which can hold not only data, but also design elements, programming code, etc.
So how do you access a Notes database? On a local workstation, many people use the Notes client. The client is an application that allows you to manage and work with any number of Notes databases. The databases can be stored either on the local workstation or on a remote server, and most people who use a Notes client have a mix of local and remote databases that they access. On the client, however, the local and remote databases look and act exactly the same.
The various databases on your Notes “workspace” can interact with each other programmatically, which makes it very easy to design workflow applications. For example, you could design an expense tracking database that sends reimbursement requests to an HR group via e-mail (another database), which in turn might tie in to a departmental budget database. Notes databases can also interact with non-Notes databases in various ways (usually via ODBC), which makes it possible to include other systems in your environment as well.
If you don’t want to use the Notes client to access a Notes database, you can also access it on a Notes server via a web browser. Since version 4.5, the Notes server software has shipped with a web server component called “Domino”, which translates Notes data into web pages and serves them up as a web site. In some cases, no additional programming or design work is necessary for Notes design elements to be viewed as a web page — all of the conversion is done automatically by the Domino server. In other cases, a Form or View might be modified somewhat for a nicer look on the web, or to provide more of the interactive experience that the Notes client provides. To this end, you can include JavaScript and Java applets directly in your Notes design elements, and you can use DHTML and CSS to provide a more pleasant “look and feel” on the web.
While a Domino server is an HTTP/HTTPS web server unto itself, with no additional software required, you can also connect Domino with other web servers like IIS and Apache. Domino even has its own Java servlet engine and a Java interface to much of the Notes object model, so you can do things like write JSP pages that interact directly with your databases.
If you have multiple Notes/Domino servers, there is a very useful feature called Replication that is built-in to the product. Using Replication, you can keep copies of the same database on multiple servers in sync, so that they automatically update themselves with the latest data and design elements throughout the day. You can even use Replication to make a local copy of a database on your workstation, modify the data offline, and then Replicate your changes back to the server when you reconnect.
Of course, Notes also provides a strong security model to limit the ways in which various users can manipulate or even view the data in a database. Every Notes database has an Access Control List (or ACL) that determines what different users are allowed to do with the data in the database. On a global level, users have access levels such as “Author”, “Editor”, and “Designer”, which indicate what they are allowed to change within the database. On a slightly more specific level, users can be granted or denied access to do things like delete documents or create agents. On a much more granular level, the designer of a database can grant or deny access to views, forms, sections of forms, and even individual documents based on the ACL.
There are certainly many other aspects of Lotus Notes that I haven’t even started to touch on here — LDAP integration, clustering, COM/OLE, CORBA — but covering all of that would take an entire book (and indeed, there are several good books that attempt to cover it). I haven’t even gone very deep into the specifics of the topics that I’ve mentioned, again for the sake of brevity. However, this overview should be able to give you an initial understanding of the basic architecture of Notes, along with a taste of what can be possible when you take all of these technology ideas and combine them in a single product.
Unfortunately, Lotus Notes is a technology that usually has to be seen to be understood. To help you envision what Notes can actually do in a practical sense, here are some examples of typical Notes applications:
- e-mail (obviously)
- discussion forums
- document repositories
- expense approval systems
- web-based request systems
Using the capabilities of Notes to interact with other database systems and other web technologies, you could also use it as a client-based or web-based information portal that ties together a number of different data sources. Lotus Notes can be a stand-alone data repository, a front-end to numerous other data repositories, or many things in-between.
Chapter 3
A Lotus Notes database generally has a file extension of “.nsf”. Within that file, there can be data, design elements, and programming code. Each database file also has its own security in the form of an Access Control List (ACL). Visually, you can imagine a Notes database file like this:
A brief discussion of the elements of a database is below.
DATA
The data inside a Notes database is stored as a set of records — each record is referred to as a Document. The information in a Document consists of one or more fields, which can be in any number of formats. Text, numbers, and dates are the basic data types, but you can also store things like formatted rich text and file attachments in a field.
A Notes database can also access data from other databases. These databases can be other Notes databases, or any kind of database that is accessible via ODBC. In this way, Notes can act as a front-end to other data sets, even relational databases.
DESIGN
Data is available using any of a number of different design elements that are stored in the database. On a basic level, you use Forms to access, modify, and create records/Documents, and Views to sort and categorize data sets into tabular form. There are also things like Navigators and Outlines, that allow you to create visual interfaces to other design elements and aid in navigation.
Virtually all of the design elements in a database can be viewed using either a Notes client or a web browser. The Notes/Domino server can natively translate these things and present them as web pages, which makes it quite easy to turn a Notes database into a web site. A Notes designer can even add web-specific design enhancements like CSS and DHTML to a Form, View, Navigator, etc.
CODE
In order to provide programmatic manipulation of data, a designer can embed many different types of code in a database. Notes has native support for a Formula (macro) language, LotusScript (very similar to Visual Basic), Java, and JavaScript. This code can be placed directly on design elements such as Forms and Views, or it can be placed in modules called Agents.
The code in a database can manipulate data within the database, but it can also interact with the user, the operating system, and external data and processes as well. For example, using LotusScript you can access DLL functions, COM objects, and OLE objects. Using Java, you have a rich set of tools for working with sockets, threads, and GUI components (among other things). Notes even has an exposed API layer that can be accessed via C and C++ libraries.
SECURITY
Wrapped around all of these database elements, Notes provides a strong security layer called an Access Control List (ACL). This allows a database designer or administrator to fine tune what different users are allowed to do within the database. On a global level, users have access types such as “Author”, “Editor”, and “Designer”, which indicate what they are allowed to change within the database. On a slightly more specific level, users can be granted or denied access to do things like delete Documents or create Agents. On a much more granular level, the designer of a database can grant or deny access to Views, Forms, sections of Forms, and even individual Documents based on the ACL.
Identification and description
| Full name | Lotus Notes Storage Facility |
| Description | The Notes Storage Facility (NSF) non-relational database file is used by IBM Lotus Notes and Domino software to store different kinds of data stored in Notes including email messages, chat and instant messages, documents, appointments and other calendar entries. A Note is similar in concept an object store because it normally contains both an application design and its associated data. This format description covers all versions of NSF. The mailbox database comprising Note types such as email messages, chat and instant messages, calendars entries and the list of To-Do as well as other archived data is stored in a single username.nsf file for each individual user. Contact Notes in the address book database are stored in the names.nsf file although contacts also can be saved into a readable format-vCard (VCF) or Comma Separated Value (CSV) file. A third important component are Notebooks, also known as Personal Journals, comprises of personal documents and information that can define the priority documents of the custodian. This database of Notes gets saved into the notebook.nsf file. Structurally, a NSF file contains a file header (made up of a signature and the database header size), followed by the database header comprised of, among other data points, the software version information (not NSF file format version), file size and database identifier (DBID) the value of which consists an NSF date and time. Replication information (DBREPLICAINFO) is an important part of the database header. IBM Domino servers and Lotus Notes clients identify NSF files by their Replication Identifier (the value which consists an NSF date and time in local time) and keep replicate files synchronized by bi-directionally exchanging data, metadata, and application logic and design. Replication history, including direction (never, send, receive), is also stored in the database header. See General for more information about replication. The database header is followed by various data constructs including: superblock (containing a header, data and footer) bucket descriptor block (containing a header, data and footer) bitmap Record Relocation Vector (RRV) bucket summary buckets, and non-summary buckets. |
| Relationship to other formats | |
| Affinity to | vCard, Virtual Card Format (vCard). The Lotus Notes Storage Facility database file can save contacts in the vCard format. |
Local use
| LC experience or existing holdings | |
| LC preference |
Sustainability factors
| Disclosure | Open partial documentation produced by Joachim Metz. |
| Documentation | Notes Storage Facility (NSF) non-relational database file format: Analysis of the NFS database file format is a working document for the NSF specification but is not yet complete. |
| Adoption | Highly adopted thanks to what Wikipedia calls a “long market history and large installed base.” Its encryption capabilities make it a popular choice among federal agencies and corporate entities dealing with classified and sensitive material. Reports of repeated predictions of the decline or impending demise of IBM Notes and Domino have long circulated although new software releases continue. In November 2014, IBM announced a new web-based product for email services named Verse which may encourage existing Notes users migrate into Verse. Email NSF files can be exported to a variety of formats. Starting with Release Notes 8.5.2, export to EML was introduced. Options prior to that included “Adobe Acrobat (presumably a PDF variant) or some other such file type” and export to ASCII Text or Microsoft RTF file “which exports the content of the message including the To, cc and bcc fields. The exported data can be used as an attachment.” |
| Licensing and patents | NSF files are intended for use only with IBM Lotus Notes and Domino software. Patents are unknown but are presumed to exist. Comments welcome. |
| Transparency | According the to IANA registration, NSF files are binary with base64 encoding preferred. Encryption is well-supported and has a long history in Notes starting with Release 1.0 which introduced with mail and port encryption. The use of encryption was extended in Release 2.0 with document encryption and secret keys for field-level encryption. Database and database design encryption were added in Release 4.0, and Release 4.5 included document encryption with public keys. With email messages, only the plaintext Body field encrypted as cyphertext, not the Subject, Sender, and Date fields. Email messages can be encrypted before sending, after receipt or before saving. Email message encryption is accomplished through “a public and private key set to encrypt and decrypt data, as well as to validate digital signatures. The public and private key in a set are mathematically related to each other and are unique to your User ID. Your public key is stored in your Notes certificate. Your certificate is stored in your User ID and the Domino Directory. Your private key is stored only in your User ID.” Encrypted messages sent by other people use the public key from the intended recipients certificate located in the Domino Directory. When an encrypted messages is received, the private key in User ID decrypts the data. IBM DeveloperWorks explains that full database encryption (defined in the DBCREATE_ENCRYPT_ field) are labeled as None, Simple, Medium, Strong adding that “the stronger the encryption, the longer it takes to open the database. So long as you’re not using disk compression, in most cases, the best option is medium encryption because of its balance between security strength and speedy access; however, if you’re using disk compression, select simple encryption so that the disk compression works effectively.” Security information is stored in the Lotus Notes ID file, usually ending in a *.id extension. The security information along with the user password permits access to a server and personal encrypted information. The length of the encryption key is limited appropriately to achieve a balance between encryption process time and security. Under current US export laws, IBM Notes supports only one version of the Notes PKI with 128-bit symmetric keys, 1024-bit public keys, and no workload reduction factor. See Historyfor more background on encryption key lengths and their impact on Notes. |
| Self-documentation | Metadata documenting important characteristics of the resource found in the NSF file and database. |
| External dependencies | NSF files are intended for use only with IBM Lotus Notes and Domino software. |
| Technical protection considerations | There are a number of methods to export data out of Notes into other formats. The Export Utility for Lotus Notes Release 6.x listed on the IBM Global Solutions site exports Notes documents and view data to PDF, HTML, IBM Connections, MS-Word, MS-Excel, MS-Access, XML, CSV, Fixed Width and other character delimited file formats. However this product will be discontinued by the developer AGECOM products on November 27, 2020. |
Since its first release in 1989, long before the topic became fashionable in the DB and web research communities, Lotus Notes had been targeted at the management of semi-structured data. Notes supports the storage and manipulation of documents (notes) that contain structured as well as unstructured data (e.g., audio, video). Views can be used for the presentation of a subset of the data in the documents of a DB in a structured way. View columns can have collation options associated with them. From the GUI, forms can be used to create, view and update documents. The Notes API can be used by programs for performing these and other operations. Document sizes could vary widely. Every document in a Notes DB could potentially be structured differently (e.g., with respect to number and types of fields) compared to every other document in the same DB. Document structure could evolve easily over time. At anytime, existing fields in a document could be deleted or their types could be modified, and new fields could be added. A document can point to another document, in the same or different DB, via a DocLink. Parent-child relationships
could exist between documents. In addition, documents could be classified along category hierarchies. Querying of a DB’s contents can be done using a fairly high-level query language, although the latter is not as sophisticated as the recently proposed query languages for semistructured DBs and XML data. Since Notes does not have an RDBMS-style query optimizer, choice of an access path to process a query needs to be made by the user.
All user data and metadata belonging to a Notes DB is stored in a single file dedicated to that DB. A server or a client can manage any number of DBs. Data is stored on disk in a machine-independent format so that binary copying of a DB file across dissimilar machine architectures (e.g., PC and RISC) does not require any conversions to be performed before the DB becomes accessible on the target system. Because of the unstructured nature of the supported data model, DBs as well as individual documents within them are stored in a completely location independent and self-describing format. Storage management is done differently for structured fields versus multimedia or rich text fields (e.g., attachments). Within a DB (e.g., when an index entry points to a document), a document is identified using a short NoteID and across DBs (e.g., for replication purposes) it is identified using a longer UNID (Universal Note ID). Sophisticated (hierarchical and ranked) B + -trees are used for managing views. The latter are like the indexes or materialized views of RDBMSs. With each view, an expression can be associated to determine which documents in the DB qualify to be included in the view. Unlike RDBMS indexes, Notes views are not maintained synchronously as the underlying documents are updated. Timestamps contained in documents and in tombstones of deleted documents are exploited to efficiently update the views. Not using a log for this purpose poses an interesting problem since the old values of a modified document’s fields are not available to compute and remove the old key. This has been resolved by maintaining for each view an inverse NoteID to key mapping. Full text indexes are managed differently from view indexes and are maintained in files external to a Notes DB file. A single so-called Domain Index can be used to index multiple Notes DBs to allow uniform searching across those DB
Through companion products like NotesPump and DECS (Domino Enterprise Connection Services), it is possible to integrate data from Notes and other sources (e.g., RDBMSs, SAP R/3). Notes applications can be written as if all the data comes from a Notes DB itself when in fact some of the data may be dynamically or periodically materialized from other sources. This is one way to integrate backend enterprise data using Notes on the desktop. Domino can be accessed from not only Notes but also web browsers and CORBA clients. Similarly, Notes can be used to access not only Domino but also CORBA, SMTP and POP3 servers.
IBM Lotus Notes access for SAP solutions is a new feature of the Lotus Notes client that provides business value for companies using both Lotus Notes software and SAP enterprise systems. It lets you access SAP information and business processes in your familiar Lotus Notes messaging and collaborative environment. By making it easier for employees to access the information they need, from a single interface, use of this feature can result in higher user productivity and faster decision making with the opportunity to reduce training costs. The Lotus Notes access for SAP solutions feature builds on proven IBM and SAP integration technology that has been on the market for eight years. The new capabilities extend this integration into calendars and scheduling, contact management, workflow processing, and other common business tasks. This feature leverages Lotus Notes strengths in personal information and workflow management to complement SAP application processes. Lotus Notes access for SAP solutions is delivered with customization in mind. Using IBM Lotus Domino Designer®, developers can see all the code. And the Notes access for SAP solutions Install database lists all the new and modified design elements used by the feature, and provides a mechanism for building the production templates according to the capabilities you want to deploy to your users.
Chapter 4
The Lotus Notes access for SAP solutions feature leverages a subset of the technology delivered with the Lotus Connector for SAP Solutions software product. The Lotus Notes access for SAP solutions feature is a Lotus Notes client-based solution. You do not need the Lotus Connector for SAP Solutions product in order to use the Lotus Notes access for SAP solutions feature. The Lotus Connector for SAP Solutions product is an extra-cost option that enables you to centralize connectivity to SAP applications on a Lotus Domino server. The Lotus Notes access for SAP solutions feature comes with a special client-side version of the SAP Connector, which: Handles authentication with SAP. Provides access to Remote Function Calls (RFCs), bUsiness Application Programming Interfaces (BAPIs), and transactions. See the glossary in Appendix A, “Useful SAP information” on page 109 for a complete description of these terms. Both the client-based feature and the server-based product use the Lotus Connector LSX to make remote function calls using a Lotus Connector designed for connectivity to SAP applications. The server-based product also includes additional features that allow this Lotus Connector to be used with IBM Lotus Enterprise Integrator® software or the Lotus Domino Enterprise Connection Services feature of the Lotus Domino server. Both the client-based feature and the server-based product include features that allow SAP workflow items to be surfaced in their Lotus Notes Inbox. The SAP workflow item feature in the Lotus Notes Connector for SAP Solutions product uses a mix of Lotus Domino server-side integration and Lotus Notes client-side integration with SAP software. The workflow integration capability of the Lotus Notes access for SAP solutions feature is strictly Lotus Notes client-side integration. The Lotus Connector for SAP Solutions product is supported for use with Lotus Notes versions 6.0.x, 6.5.x, and 7.0, while the Lotus Notes access for SAP solutions feature is available for Lotus Notes 7.0.1 and later. IBM Lotus Enterprise Integrator for Domino, also called Lotus Enterprise Integrator, enables you to develop enterprise integration solutions without needing to program in LotusScript. When used with Lotus Connector for SAP Solutions, Lotus Enterprise Integrator provides industrial strength, real-time data access to, as well as batch-mode data transfer and synchronization with, SAP applications. The business benefits of Lotus Enterprise Integrator include reducing application development time and improved administration of integrated solutions. The
Lotus Notes access for SAP solutions front end The Lotus Notes access for SAP solutions front end, as with all Notes applications, can be divided into the presentation layer, what we see in Notes, and the underlying design elements, forms, subforms, views, and so on. The Lotus Notes access for SAP solutions front end is nothing more than a Notes application. The Notes client UI presents intuitive options for users to request and view data. Beneath the UI, we find fields on the forms that format the data going to and from SAP in a usable manner. (See 4.5, “Step 4: Passing SAP data to the UI” on page 86 for more details.) After the data is properly formatted, it is stored in a temporary Notes document. Using a Notes document to store all the data allows us to have a familiar container from which we can User Interface (UI) LotusScript Libraries LC LSX (Connector API) SAP Connector SAP Client DLL NaSs Templates SAP Lotus Notes access for SAP solutions 7 access all our data. We do not have to know the SAP details; they are hidden in the script libraries of the Lotus Notes access for SAP solutions back end. We only need to know how to access Notes fields on a form to retrieve SAP data for display in the Notes client UI.
Lotus Notes access for SAP solutions back end The Lotus Notes access for SAP solutions back end consists of a group of script libraries that do the work needed to transform the Notes client UI inputs into commands that can run the SAP BAPIs and RFCs. The functions within these script libraries take care of the SAP details. These functions are then used in Notes agents to take the inputs from the Notes temporary storage document, use these inputs to execute SAP functions, and return output and table results sets from SAP back to the temporary Notes storage document. These values are stored as arrays in the Notes document and can easily be accessed by the Notes UI. At the heart of the Lotus Notes access for SAP solutions feature are the LC LSX classes that have been available since Lotus Domino version 4.6. These classes allow Notes application developers to access back-end relational databases through LotusScript. At the center of the Lotus Notes access for SAP solutions script libraries are calls to the LC LSX classes. Because of the LC LSX classes, all that was needed to access SAP was to develop an SAP connection file that allows the LC LSX classes to talk to the SAP client software.
Beginning with Lotus Notes 7.0.1, out-of-the-box installations include the SAP connector needed to allow the LC LSX classes to access an SAP system. Finally, the back-end (SAP) client software is required. The SAP client file (librfc32.dll) must be obtained directly from SAP. To summarize, the Lotus Notes access for SAP solutions architects took the LC LSX classes that have been used for years to access back-end database systems and built a set of script libraries and Notes UI design elements to ease information swapping between Notes and SAP. They used the Notes document object as a conduit to pass information to and from the Notes UI to the SAP back end. Other than including the SAP connector in the Lotus Notes 7.0.1 client, no new client functionality was added. The Lotus Notes access for SAP solutions feature is based on existing Domino standards. The division of labor between the Notes UI and back-end LotusScript libraries coupled with a Notes document as a container for the inputs and outputs make the Lotus Notes access for SAP solutions architecture a relatively easy framework from which to integrate Notes and SAP data.