In previous entries, we've discussed how to use the Domino CRUD API in the following ways:

• Understanding the Domino CRUD API - the Basics

  Where I first introduced and discussed the Domino URL Commands that you can use to interact with the Domino CRUD engine.

• Understanding the Domino CRUD API - $$Return Basics

  Where I showed you - via screencast - how to control the Web Browser client session post-NotesDocument Create/Update submission with the reserved $$Return NotesItem.

• Understanding the Domino CRUD API: $$Return and Smart Landing Pages

  Where I showed you - via screencast - how to use the $$Return NotesItem in combination with URL QueryString Parameters, Formula language, NotesDocumentUNIDs, and a Page Design Element to create context sensitive Smart Landing Pages for the Web Browser Client post-NotesDocument Create/Update submission.

Now I'll show how you can create your own non-Domino Form Design Element-based XHTML Form Elements that use the Domino CRUD API for NotesDatabase Data Management. In this, the Part 1 in a smaller part of the overall Understanding the Domino CRUD API series, I'll show you how you can create a simple Domino Page Design Element that can be used to Create and Update NotesDocument data.

NOTE: I'm opening up the Domino CRUD API Example NotesDatabase to Anonymous access having Editor w/ Delete. I'll keep it that way as long as we all play nicely. Someone playing script-kiddie and putting some cross-browser attack or posting inappropriate content will ruin this for everyone (as well as give me the burded of shutting things down). Should go without say, but...

First thing first, we'll talk about the ingredients for this build:

1. Page Design Element: content.html

   This is going to be - on purpose - a very basic build. I could get really creative with this XHTML (Content-Type: text/html) webpage, but that might distract from the overall example.

2. Input/Textarea Element name Attribute match

   This one is simple yet very powerful. If you're NotesItem is named title, your XHTML Form Element's Input Element name for title needs to be title!

3. NotesDocumentUNID passthru Logic

   Just like with the Smart Landing Page - which is a basic example of an advanced Domino Design Element-driven Domino CRUD Read - we'll be using a NotesDocumentUNID to drive the Update XHTML page Form population.

4. ?CreateDocument Domino URL Command

   We'll use this to facilitate the Create Domino CRUD verb.

5. ?SaveDocument Domino URL Command

   We'll use this to facilitate the Update Domino CRUD verb.

First, we'll create our simple content.html Page Design Element:

Simple, and will get the job done. Two major things to point out here: the Form Element's processing agent and the value attribute for each Input Element.

The Form Element's processing agent - as shown - uses a Computed Text instance to populate it's action:

~UNID := @UrlQueryString("UNID");
@If(~UNID = ""; "content?CreateDocument"; "0/" + ~UNID + "?SaveDocument")

This simply checks the URL Query String for a parameter named UNID. If found, I know I'm going to Update a NotesDocument. Otherwise I'm going to Create a new NotesDocument.

The Computed Text set as the values of our Input and Textarea Elements does someting similar (for the Title Input Element):

~UNID := @UrlQueryString("UNID");
@If(~UNID = ""; ""; @GetDocField(~UNID; "title"))

When we click submit - via the simple Input Element typed "submit" - we're going to rely on our XHTML Form Element's processing agent to handle the rest.

For new NotesDocuments, we see that it's pointing to the Content Domino Form Design Element and will issue the ?CreateDocument Domino URL Command. This will result on a NotesDocument being creating in the target NotesDatabase and leverage the $$Return to redirect our Web Browser Client session post-submission to our Smart Landing Page.

For existing NotesDocuments, we'll use the following syntax:

/0/NotesDocumentUNID?SaveDocument

Same thing here - the ?SaveDocument does the real work here via the Domino CRUD engine and performs an Update with the submitted XHTML Form Element contents.

NOTE: Notice the /0/ placeholder for the View Design Element in the XHTML Form Element's processing agent. If you replaced this with /pages/, it would honor the pages View Design Element's Form Formula, thus first rendering/submitting the NotesDocument via the display Form Design Element and - since there is no $$Return - would simply return the Form Processed message to the Web Browser Client.

The last part of this is to direct people to an edit link for each NotesDocument in your Pages View Design Element:

~t := @If(title = ""; "Untitled Content"; title);
~pl := "<a href=\"pages/" + permalink + "\">Use Permalink</a>";
~unidl := "<a href=\"pages/" + @Text(@DocumentUniqueID) + "\">Use UNID</a>";
~htmledit := "<a href=\"content.html?open&UNID=" + @Text(@DocumentUniqueID) + "\">Edit</a>";

"<tr><td class=\"col0\">" + ~t + "</td><td class=\"col1\">" + ~pl + "</td><td class=\"col2\">" + ~unidl + "</td><td class=\"col3\">" + ~htmledit + "</td></tr>"

The ~htmledit gives us the UNID URL Query String Parameter required for our Update, and the rest is handled by the Domino CRUD engine!

Wanna play? I've enabled Anonymous access to the Understanding the Domino CRUD API Example NotesDatabase. You should have Editor access with the Delete role enabled.

In our next entry - Understanding the Domino CRUD API: non-Domino Form CRUD Basics - Part 2 - we'll discuss how you can handle Read and Delete CRUD verbs - completing the Basics subsection of the non-Domino approach. After that, we'll get into some pretty advanced stuff!

Hopefully you'll start to see - especially after this - exactly where we can go from here. My XHTML Form was created in Aptana and outside of it's using Computed Text to populate the XHTML Form Element really wouldn't need to reside in a NotesDatabase at all. See... getting a firm handle on this stuff is the ground work for extending your Domino Web Application Development to new heights: integrating with other technology investments and SaaS/cloud services!

In the last video, I showed how you can use the $$Return in combination with some basic markup to create a simple Create and Update submission confirmation message or redirect to a URL.

In this video, I talk about creating a context-sensitive Smart Landing Page that uses a combination of Page Design Element, URL QueryString Parameter, XHTML, and some JavaScript to create a user experience that we're used to in Web Browser Applications.

Consider this my entry for Show-and-Tell-Thursday. ;-)

Questions, comments, and suggestions welcomed and appreciated!

Learn how you can return custom NotesDocument submission messages and redirect to specific URLs with the Domino Rapid Application Development (RAD)-friendly $$Return.

This screencast, running 3:55, just touches the surface on what you can do with a $$Return in the world of the Domino CRUD API.

IBM Lotus Notes/Domino has a pretty easy to use and powerful CRUD - or (Create, Read, Update, Delete) NotesDatabase Data Engine - complete with a defined Web-accessible API.

The best part is... the majority of Domino Web Application Developers are already using it!

Note: I'll be using the term processing agent below. This is not to be confused with a Domino Agent Design Element, but is rather the XHTML Form Element's action attribute. See http://www.htmlquick.com/tutorials/forms.html for an example.

I'll make no assumptions here that you're familiar with the Domino URL Commands that handle all CRUD activities and just jump into them, as understanding them at a very basic level is required for a few more deep dive things that I want to get into. Thus, I'll list the Domino URL Command and how it's used below:

• Type: Read

  ?OpenDocument
  Usage: http://server/database/viewname/notesdocument?OpenDocument

  This Domino URL Command allows you to open or read a NotesDocument. This URL Command can be ommited, as the default render option for a Form Design Element when viewing a NotesDocument via the Web Browser Client is to open said NotesDocument in Read Mode.

  It should be noted that the Form Design Element used to render the NotesDocument will render in the following order:

  1. Form Design Element defined in the Form Formula section of the viewname View Design Element.
  2. Form Design Element defined in the Form NotesItem of the rendered NotesDocument.
  3. The Default Form Design Element for the target NotesDabase.

• Type: Create

  ?CreateDocument
  Usage: http://server/database/formname?CreateDocument

  This Domino URL Command allows you to create a new NotesDocument in the target NotesDatabase via the Form Design Element defined in the URL. HTML Input and like elements (fields) with exact name-match to NotesItems in the defined Form Design Element will exchange data.

• Type: Read

  ?EditDocument
  Usage: http://server/database/viewname/notesdocument?EditDocument

  This Domino URL Command does two things:
  1. Verifies your access to render the defined NotesDocument in Edit Mode.
  2. Renders the defined NotesDocument in Edit Mode via the same applied Form Design Element Logic as the ?OpenDocument Domino URL Command. (see above)

  This Domino URL Command does nothing functional per se, as it is used more to verify editor-access to the defined NotesDocument and tells the Domino to render - as mentioned - the NotesDocument via the Edit Mode version of the aforementioned logic-driven Form Design Element.

• Type: Update

  ?SaveDocument
  Usage: http://server/database/viewname/notesdocument?SaveDocument

  This Domino URL Command allows you to update the defined NotesDocument in the target NotesDatabase. HTML Input and like elements (fields) with exact name-match to NotesItems in the Form Design Element rendered via the aforementioned Form Design Element rendering logic. (see above)

• Type: Delete

  ?DeleteDocument
  Usage: http://server/database/viewname/notesdocument?DeleteDocument

  This Domino URL Command allows you to submit a deletion request for the defined NotesDocument in the target NotesDatabase. Simply put, if you have the proper level of access to the NotesDatabase (and to the NotesDocument), once you issue this request Domino will take care of the rest.

So that's pretty much it for a basic overview of the Domion URL Commands that run the Domino CRUD engine. Simple - hopefully - because you're all familiar with them due to their extensive usage in Domino RAD.

For example, if you look at the HTTP Form Element's processing agent for most Domino RAD-generated Forms, you'll see these Domino URL Commands in-use.

I think understanding the Domino CRUD API will enable you to both write better, richer, Domino-based Web Browser Client User Experiences as well as give you an eye to what can be done via simple integration with other/non-Domino technologies.

Hopefully this is useful to those of you looking to get into Domino Web Application Development, and the next few posts on this topic will act as a refresher for those old hands that have been doing this for years... but I went back to the basics because, well, that's for the next post!