Integrating IBM Lotus Domino into Your Portlets with IBM WebSphere Portlet Factory

1
(No Transcript)
2
Integrating IBM Lotus Domino into Your Portlets
with IBM WebSphere Portlet Factory
3
Agenda

• Brief overview of IBM WebSphere Portlet Factory
• Demo - building a Domino-based portlet using SOA
• Using additional Domino integration features
• Searching and categories
• Agents and formulas
• Keyword lookups
• Demos
• Additional Portlet Factory features
• AJAX and rich UI
• Support for any back end data source
• Dynamic profiling
• Demos
• Q A

4
IBM WebSphere Portlet Factory

• Portal and web application development
  environment for building composite applications
• Ships with WebSphere Portal 6
• Also works with WebSphere Portal 5.1 and with
  WebSphere Application Server 5.1 or 6
• Used as the platform for IBM Workplace Dashboard
  Framework

5
Key features of Portlet Factory

• Multi-page custom portlets without coding
• Integration capabilities (SAP, Domino,
  PeopleSoft, Siebel, Web Services, Databases,
  Portal Content Repository)
• Service-oriented development
• Support for Portal features such as portlet
  communication, business user configuration,
  auto-deploy, Single Sign On (SSO)
• Profiling capability, to create multiple
  variations from a single source model
• All these are enabled by Portlet Factorys
  software automation technology

6
Software automation in Portlet Factory

• Portlet Factory harnesses the power of
  manufacturing automation and applies it to
  software
• Manufacturing automation uses technology such as
  robots on an assembly line to increase
  productivity and quality
• Software automation enables the construction of
  "digital factories" that capture and automate the
  development process
• Portlet Factory was designed from the ground up
  to use software automation to address complex
  software development tasks, such as
• Portlet and J2EE development
• Integration with complex back end systems
• Developing rich UI and forms
• Developing large composite applications with
  consistent UI and implementation

7
Key concepts Builders

• Capture design patterns and automate the creation
  of code
• Create or modify any number of application
  elements and artifacts
• Pages, schemas and data, server-side and
  client-side actions and logic, back end
  connectivity, etc.
• JSP, Java, XML, JavaScript, etc.
• Perform automation tasks based on the inputs or
  parameters specified by developers
• Have easy to use, wizard-like interfaces

/ Generated Method employees_SelectRow
/ public void employees_SelectRow(WebAppAccess
webAppAccess, Integer rowIndex, String
nextAction) int index
rowIndex.intValue() Variables vars
webAppAccess.getVariables() int selectedRow
index - 1 IXml data vars.getXml("employee
sGetEmployeesByDeptResults") if (data
null) return data data.findElement("Employe
eList") if (data null) return int
row 0 IXml child data.getFirstChildElemen
t() while (child ! null) if (row
selectedRow) vars.setXml("employees_Sele
ctedRowData", child) break
row child child.getNextSiblingElement(
) webAppAccess.callMethod(
"employeesGetEmployeeRecord" )
webAppAccess.processAction(nextAction)
8
Key concepts Models

• Models are containers for aggregating builders
• A model is typically used to create a service or
  a portlet
• Developers work iteratively with builders in a
  model to create a custom assembly line
• A model captures the design intent and logic of
  the development process itself
• Models can run on demand to generate new
  application variations

9
Typical portlet development high-level steps

1. Create and test service model for data access
2. Create presentation model, with high-level
   builder to create the initial user interface
3. Customize application iteratively, by adding or
   changing builders

10
1. Create a service model
getViewData() readDocument() updateDocument()
getViewData() readDocument() updateDocument()
Domino Database
This Domino Data Access builder generates access
to back end data and generates schemas that
describe the data structures
This Service Definition builder defines the
overall service and generates test pages and code
These Service Operation builders add public
operations to the service and define field
mapping to back end data
getEmployeesByDept() getEmployeeRecord() updateEmp
loyeeRecord()
getEmployeesByDept() getEmployeeRecord() updateEmp
loyeeRecord()
11
2. Create the initial presentation model
This Service Consumer builder adds service
metadata and schemas, along with code for calling
the service
employeesGetEmployeesByDept() employeesGetEmployee
Record() employeesUpdateEmployeeRecord()
This View Form builder uses schema information
to create pages for list, details, and update,
along with navigation and supporting code
12
3. Customize the presentation model
This Data Column Modifier builder hides and
reorders columns and adds sorting
This Rich Data Definition builder controls all
the formatting, validation, display, and editing
of fields on all the pages
13
Demo
14
IBM WebSphere Portal
Portal-based Composite Apps
IBM WebSphere Portlet Factory
Business Information
Services
Business Information

• Enterprise Apps
• SAP
• Siebel
• PeopleSoft
• Custom

Portlets

• Information
• OLAP / Cubes
• Warehouse / Mart
• Databases

Employee Self Service

• BPM
• Processes
• Monitors

Dashboards

• Other
• Domino
• Spreadsheets
• Documents

Collaboration
Partner/Customer Self-Service
Security/SSO
BPEL/Workflow
Portal Services
15
Using SOA approach vs. direct-to-Domino builders

• Demo showed best practice techniques for back
  end integration
• Uses service provider/consumer architecture
• Direct-to-Domino single-model approach is also
  available, using Domino View Form builder
• Some Domino-related tasks are initially quicker
  with single-model approach
• Domino View Form builder creates functionality
  with a single builder
• but SOA approach has benefits

16
Benefits of service provider/consumer architecture

• Easily test back end services without front end
• Develop presentation model without any back end
  access, using a stub service model
• Reuse services in multiple presentation models
• Easily transform data between back end schema and
  some other schema
• Switch between multiple implementations of a
  service interface without changing consumer model

17
Using additional Domino integration features

• Search and categories
• Formulas and agents
• Keyword lookups

18
Using Domino categories and search

• Data from Domino Views can include category data
• Categorized data can be displayed with twisties
• Use Category View builder for this
• Views can be filtered
• Using full text search
• By category
• This is controlled by inputs in Domino Data
  Access builder

19
Using formulas and agents

• Any Domino agent can be invoked with runAgent()
  method
• Optionally can pass UNID to enable agent access
  to a specific document
• In service model, an agent can be called as part
  of the service execution
• Formulas can be executed with evaluateFormula()
  method
• Optional UNID parameter for formulas that access
  a document
• To display a formula value on a page, can use
  Domino Formula builder

20
Keyword lookups

• Text/value pairs can be retrieved from Domino
• Internal value is stored in Domino readable text
  is displayed for user
• Two implementation techniques for these lookup
  tables
• Use Domino Keyword Lookup builder
• Use service operations and Lookup Table builder

21
More Domino features

• Domino Attachment builder provides support for
  downloading attachments
• Send mail
• Access to Domino Java objects such as Session,
  View, and Document

22
Additional Portlet Factory features

• AJAX and rich UI
• Support for any back end data source
• Dynamic profiling

23
Enhancing the application user interface

• Portlet Factory has a rich set of builders for
  enhancing and modifying the application user
  interface
• These builders can be added to a model after the
  initial UI is created with a builder such as View
  Form
• These modification builders can be targeted at a
  specific piece of UI, or applied to a whole set
  of UI components
• Example Rich Data Definition builder applies
  rich user interface characteristics (validation,
  formatting, UI type, labels, etc.) to all the
  pages generated from a specified schema
• Example Data Field Modifier targets specific
  fields and sets UI characteristics

24
AJAX and rich UI builders

• New builders in Portlet Factory 6.0.1 can
  automatically enable AJAX features
• Builders generate all the necessary client-side
  and server-side code
• Features include
• Partial page rendering and AJAX Region builder
• AJAX Type-Ahead builder
• Dynamic Validation builder
• Timed Action builder
• Dojo drag/drop builders
• Dojo Tooltip builder
• Dojo Inline Edit builder
• XML/JavaScript Converter (JSON) builder
• Highlighter builder
• Automatic support for creating REST-style
  services from any back end data

25
Support for any back end data source

• All data access builders create the same
  abstractions as Domino Data Access builder
• Schemas and operations with parameters
• Each data access builder has a UI appropriate for
  connecting to the specific back end
• SAP select BAPI or function
• JDBC specify Data Source and SQL
• PeopleSoft select Component Interface
• Siebel select Business Component
• All the other Portlet Factory builders can work
  with any back end data, using the schemas and
  operations
• The choice of service provider can be dynamically
  switched without changing consumer model at all
• Between different implementations or to stub
  implementation

26
Dynamic profiling

• Portlet Factory profiling is used to generate
  multiple application variations from a single
  source model
• Variations can be tied to
• Portal roles or groups
• Customers, partners, or regions
• Portlet customization by administrators or end
  users
• Profiling enables business users to customize the
  application without requiring additional coding
  by developers
• Any aspect of application can be varied by
  profile look and feel, level of functionality,
  services, logic, etc.

27
Using profiling to generate multiple application
variations from one source model
Profile Sets
Application Instances
Products
Regions
Roles
Regen Engine
Model
28
Recap

• Overview of Portlet Factory and software
  automation
• Building a Domino-based portlet using SOA
• Create service model using Domino data
• Create and customize presentation model
• Run standalone or in Portal
• Using additional Domino integration features
• Searching and categorizing
• Agents and formulas
• Keyword lookups
• Additional Portlet Factory features
• AJAX and rich UI
• Support for any back end data source
• Dynamic profiling

29
Related sessions
1/22/2007 1100am - 1200pm AD101 Lotus Software Development Tools Strategy and Roadmap
1/22/2007 1100am - 1200pm AD203 Rapidly Build Role-based, Customizable Dashboards with IBM Workplace Dashboard Framework
1/22/2007 430pm - 615pm HND107 Building IBM Lotus Domino-Driven Dashboards and Scorecards
1/23/2007 130pm - 230pm AD108 Best Practices for Creating Portlets with IBM WebSphere Portlet Factory
1/23/2007 415pm - 515pm AD109 IBM WebSphere Portlet Factory Advancing Beyond Builders
1/24/2007 0800am - 945am HND109 IBM WebSphere Portlet Factory - Is it Really That Simple? What are They NOT Showing Me?
1/24/2007 415pm - 515pm BP303 Best Practices with IBM WebSphere Portal, IBM Workplace Web Content Management, and IBM WebSphere Portlet Factory
30
Q A