IBM Rational Host Access Transformation Services
Getting Started
Version 9.0
GI13-2847-00
IBM Rational Host Access Transformation Services
Getting Started
Version 9.0
GI13-2847-00
Note
Before using this information and the product it supports, be sure to read the general information under “Notices” on page
71.
Tenth Edition (August 2013)
© Copyright IBM Corporation 2002, 2013.
US Government Users Restricted Rights – Use, duplication or disclosure restricted by GSA ADP Schedule Contract
with IBM Corp.
Contents
Chapter 1. Introducing Host Access
Transformation Services . . . . . . . 1
Chapter 4. Enabling HATS runtime and
license settings . . . . . . . . . . . 29
What is HATS? . . . . . . . . . .
A HATS 3270 example . . . . . . . .
A HATS 5250 example . . . . . . . .
What's new in HATS . . . . . . . .
New supported environments . . . .
Ease of use . . . . . . . . . .
Coexistence . . . . . . . . . . .
Migration . . . . . . . . . . . .
Serviceability . . . . . . . . . . .
IBM Support Assistant. . . . . . .
Roles and skills . . . . . . . . . .
Casual Web developer . . . . . . .
Advanced Web developer . . . . .
Casual rich client developer . . . . .
Advanced rich client developer . . . .
User . . . . . . . . . . . . .
HATS administrator . . . . . . .
WebSphere administrator . . . . . .
Rich client administrator . . . . . .
WebFacing developer . . . . . . .
Independent software vendors . . . .
Accessibility . . . . . . . . . . .
Accessibility when using HATS. . . .
Where can I find more information about
accessibility? . . . . . . . . . .
Where can I find information about HATS?.
Evaluating HATS
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. 1
. 3
. 7
. 11
. 11
. 12
. 12
. 12
. 12
. 12
. 13
. 13
. 13
. 13
. 13
. 13
. 14
. 14
. 14
. 14
. 14
. 15
. 15
.
.
.
.
. 16
. 16
Chapter 2. Introducing the WebFacing
Tool . . . . . . . . . . . . . . . . 19
What is WebFacing? . . . . .
WebFacing features . . . . .
What's new in WebFacing . . .
New supported environments .
Where can I find information about
. . . .
. . . .
. . . .
. . . .
WebFacing?
.
.
.
.
.
.
.
.
.
.
19
19
22
22
22
Chapter 3. Installing HATS . . . . . . 23
Prerequisites . . . . . . . . . . . . .
IBM Rational HATS . . . . . . . . .
IBM WebFacing Tool for IBM i feature . . .
Portal support for IBM WebFacing Tool for IBM
feature . . . . . . . . . . . . . .
Other prerequisites . . . . . . . . . .
Installing HATS Toolkit . . . . . . . . .
Updating the HATS Toolkit installation . . . .
Modifying the HATS Toolkit installation . . . .
Adding the HATS installation repository to IBM
Installation Manager . . . . . . . . . .
Uninstalling HATS Toolkit . . . . . . . .
Using silent install and uninstall . . . . . .
Log files . . . . . . . . . . . . . .
© Copyright IBM Corp. 2002, 2013
. 23
. 23
. 23
i
.
.
.
.
.
24
24
24
25
26
.
.
.
.
27
27
28
28
.
.
.
.
.
.
.
.
.
.
.
. 30
Chapter 5. Creating a basic HATS
project . . . . . . . . . . . . . . . 31
Introducing the Rational SDP environment
Starting HATS Toolkit and perspective .
Introducing the HATS Welcome page . .
Starting HATS functions . . . . . .
Using HATS icons . . . . . . .
HATS tips . . . . . . . . . .
Developing a HATS project . . . . .
Creating a HATS project . . . . .
Testing your project . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
31
31
33
34
34
35
36
36
38
Chapter 6. Customizing your HATS
project . . . . . . . . . . . . . . . 43
Understanding how a HATS application works . .
Understanding HATS resources. . . . . . .
Using the host terminal screen as you work . . .
Host screen preview . . . . . . . . . .
Working with screen captures . . . . . . .
Updating your project's template . . . . . . .
Editing default rendering . . . . . . . . . .
Creating global rules . . . . . . . . . . .
Working with screen events . . . . . . . . .
Creating a new screen customization . . . . .
Creating a new screen combination . . . . .
Ordering and enabling your screen events . . .
Working with transformations . . . . . . . .
Understanding host components and widgets . .
How HATS uses transformations . . . . . .
Creating a new transformation . . . . . . .
Performing other customization tasks. . . . . .
Auto advance . . . . . . . . . . . .
Displaying function keys (PF keys) . . . . .
Replacing text strings from the host screen . . .
Using macros . . . . . . . . . . . . .
Using Host Publisher artifacts . . . . . . .
Creating background connections . . . . . .
Defining global variables . . . . . . . . .
Applying business logic . . . . . . . . .
Using keyboard support . . . . . . . . .
Creating Integration Objects and EJB projects . .
Specifying a workstation ID . . . . . . . .
Using print support . . . . . . . . . .
Subfile support . . . . . . . . . . . .
Using Extended Field Attributes . . . . . .
Enabling Enhanced Non-Programmable Terminal
User Interface (ENPTUI) . . . . . . . . .
5250 HTML DDS keyword support Web-only
43
43
45
46
46
47
48
49
49
50
51
52
53
53
55
55
58
58
58
58
59
61
61
61
61
61
61
62
62
62
63
65
66
iii
Chapter 7. Preparing your HATS project
for use as an application . . . . . . . 67
Deploying HATS Web applications . . . .
Exporting your project as an application. .
Installing your application in a runtime
environment . . . . . . . . . . .
Deploying HATS rich client applications. . .
Exporting your project as an Eclipse feature
Exporting HATS runtime features . . . .
Creating an update site . . . . . . .
Installing your application in a runtime
environment . . . . . . . . . . .
iv
.
.
. 67
. 67
.
.
.
.
.
.
.
.
.
.
.
. 68
Notices . . . . . . . . . . . . . . 71
Programming interface information .
Trademarks . . . . . . . . .
.
.
.
.
.
.
.
.
. 72
. 73
Glossary . . . . . . . . . . . . . . 75
67
68
68
68
68
Index . . . . . . . . . . . . . . . 83
IBM Rational Host Access Transformation Services: Getting Started
Chapter 1. Introducing Host Access Transformation Services
This book provides the information you need to understand the IBM® Rational®
Host Access Transformation Services (HATS) product, install HATS Toolkit, and
use it to develop simple applications. After you have familiarized yourself with the
concepts in this book and used HATS, you can find more advanced information in
the HATS User's and Administrator's Guide, the HATS Web Application Programmer's
Guide, the HATS Rich Client Platform Programmer's Guide, the HATS Advanced Macro
Guide, and Developing WebFacing Applications.
What is HATS?
With HATS, you can create Web applications, including portlets, and rich client
applications that provide an easy-to-use graphical user interface (GUI) for your
3270 applications running on IBM System z® platforms and your 5250 applications
running on IBM i operating system platforms. HATS applications can access 5250
applications without requiring Online Transaction Processing (OLTP) capacity. In
this book, these character-based 3270 and 5250 applications are referred to as host
applications. You can also create service-oriented architecture (SOA) assets using
Web services that provide standard programming interfaces to business logic and
transactions contained within host applications. Data from video terminal (VT)
emulation screens can also be accessed.
HATS applications can be given a modern appearance. HATS Web applications,
including portlets, can be developed with an interface that matches your
company's Web or portal pages, and your users can access them through their Web
browsers. HATS Web applications can also be developed to provide access from
mobile devices such as cellular phones, data collection terminals, and personal
digital assistants (PDAs).
HATS rich client applications can be developed to run in an Eclipse Rich Client
Platform (RCP) implementation, in Lotus Notes®, or in the Lotus® Expeditor Client
to provide native client applications targeted for a user's desktop. For more
information about the Eclipse RCP environment see http://www.eclipse.org/
home/categories/rcp.php. For more information about Lotus Notes see the Lotus
Notes Information center at http://publib.boulder.ibm.com/infocenter/domhelp/
v8r0/index.jsp. For more information about the Lotus Expeditor Client see the
Lotus Expeditor Information Center at http://publib.boulder.ibm.com/infocenter/
ledoc/v6r2/index.jsp.
Note: Throughout this document, configuration settings that apply only to HATS
Web applications, including portlet and EJB applications unless otherwise
noted, are marked with Web-only. Configuration settings that apply only
to HATS rich client platform applications are marked with RCP-only.
HATS has two components:
v The HATS Toolkit is a set of plug-ins for the Eclipse-based IBM Rational
Software Delivery Platform (Rational SDP). For more on which versions of
Rational SDP are supported, see “Prerequisites” on page 23.
The HATS Toolkit enables you to develop new applications, including portlets, a
step at a time, previewing and saving each change you make. Over time, or as
quickly as you like, you can streamline your HATS application, making it easier
© Copyright IBM Corp. 2002, 2013
1
to use than the host applications whose data it presents, and possibly moving
functions from the host applications into your HATS applications. The
development process for building HATS Web and rich client applications is
similar.
After you have developed a HATS application, you deploy it to a production
runtime environment.
v The HATS runtime code runs as part of a HATS application deployed in a
production runtime environment, WebSphere® Application Server, WebSphere
Portal, or rich client platform. Users interact with the HATS application through
the HATS GUI and data is sent back and forth between the user and the host
application.
The following figure shows the stages of development, deployment, and runtime
for a HATS Web application. If the application is a portlet, the stages are similar
except that the portlet is installed and run on a WebSphere Portal system.
1. The developer uses the HATS Toolkit to develop and test a HATS Web
application.
2. When ready, the developer deploys the HATS application by exporting it as a
Java™ EE application and installing and running it on a WebSphere Application
Server system.
3. Using a Web browser, the user accesses the HATS application.
4. The HATS runtime connects to the target host system through either a Telnet or
a WebFacing server.
5. As the user interacts with the host through the HATS application, the HATS
runtime transforms host screens to a GUI.
HATS Web application
1. Develop / test
2. Deploy
HATS Toolkit
Rational SDP
WebSphere Application Server /
WebSphere Portal
HATS enterprise application / portlet
3. Access
HTML over HTTP
5. Transform
Telnet server
(3270 or 5250)
4. Connect
WebFacing server
(5250)
Web browser
Figure 1. HATS Web application
The following figure shows the stages of development, deployment, and runtime
for a HATS rich client application.
1. The developer uses the HATS Toolkit to develop and test a HATS rich client
application.
2
IBM Rational Host Access Transformation Services: Getting Started
2. When ready, the developer exports the HATS application as an Eclipse feature,
creates an update site containing the application feature, and uploads it to a
Web server for deployment.
Note: Different methods can be used for deploying HATS rich client
applications. For example, Lotus Expeditor Server can be used to
centrally manage the software deployed to Lotus Expeditor Client
systems. For more information see the HATS User's and Administrator's
Guide.
3. The user, running a rich client platform, downloads and installs the HATS
application feature from the update site.
4. The user starts and accesses the HATS application using the rich client platform
environment.
5. The HATS runtime connects to the target host system through either a Telnet or
a WebFacing server.
6. As the user interacts with the host through the HATS application, the HATS
runtime transforms host screens to a GUI.
HATS rich client application
1. Develop / test
HATS Toolkit
Rational SDP
2. Upload
Web server
Update site
HATS application
feature
3. Download
Telnet server
(3270 or 5250)
4. Access
5. Connect
6. Transform
WebFacing server
(5250)
Rich client
Figure 2. HATS rich client application
A HATS 3270 example
Imagine you need to create a GUI for a 3270 host application. With HATS you
have a choice of providing the GUI using a Web application (including portlets) or
a rich client application. For more information about the use of HATS portlets and
rich client applications, including advantages, considerations, and limitations, see
the WebSphere Portal and HATS chapter and the Developing and deploying rich
client applications chapter in the HATS User's and Administrator's Guide.
The following figure shows a screen from the host application:
Chapter 1. Introducing Host Access Transformation Services
3
ACCOUNTS
ADD ACCOUNT NUMBER 55550
SURNAME
FIRST NAME
TELEPHONE
ADDRESS LINE1
LINE2
LINE3
:
:
:
:
:
:
CARDS ISSUED
DATE ISSUED
APPROVED BY
:
:
:
:
(18 CHRS) TITLE
(12 CHRS) MIDDLE INIT :
(24 CHRS)
(24 CHRS)
(24 CHRS OPTIONAL)
CARD CODE
REASON CODE
(1 TO 9)
(MM DD YY)
(3 CHRS)
(4 CHRS OPTIONAL)
(1 CHR OPTIONAL)
:
:
(1 CHR)
(N,L,S,R)
UPTO 4 OTHERS WHO MAY CHARGE (EACH 32 CHRS OPTIONAL)
01:
02:
03:
04:
SPECIAL CODE1:
CODE2
CODE3:
(EACH 1 CHR OPTIONAL)
NO HISTORY AVAILABLE AT THIS TIME
CHARGE LIMIT
STATUS
NOTE:-DETAILS IN BRACKETS SHOW MAXIMUM NO.CHARACTERS ALLOWED AND IF OPTIONAL
FILL IN AND PRESS "ENTER," OR "CLEAR" TO CANCEL
MA*
a
03/017
Figure 3. A host terminal screen
If you decide to create a Web application that provides the GUI, you use a wizard
to create a simple HATS Web project. You give your project a name and specify the
host machine where the host application runs. You take all the defaults and add no
customization. After just a few minutes, you use the preview function to see the
host screen transformed to this:
My Company
Innovative technologies designed for the future
Home
My Company Home Page
My Company Map
My Company Employees
Jobs at My Company
My Company Articles
Support
Reset
Default
Refresh
Disconnect
Turn Keyboard Off
About My Company
Links
ACCOUNTS
Stock Quote
ADD ACCOUNT NUMBER 55550
SURNAME
FIRST NAME
TELEPHONE
ADDRESS LINE1
LINE2
LINE3
:
:
:
:
:
:
CARDS ISSUED
DATE ISSUED
APPROVED BY
:
:
:
:
(18 CHRS) TITLE
(12 CHRS) MIDDLE INIT:
(10 DIGS)
(24 CHRS)
(24 CHRS)
(24 CHRS OPTIONAL)
(1 TO 9)
(MM DD YY)
(3 CHRS)
CARD CODE :
REASON CODE:
(4 CHRS OPTIONAL)
(1 CHR OPTIONAL)
(1 CHR)
(N,L,S,R)
UPTO 4 OTHERS WHO MAY CHARGE (EACH 32 CHRS OPTIONAL)
01:
02:
03:
04:
SPECIAL CODE1: CODE2: CODE3:
(EACH 1 CHR OPTIONAL)
NO HISTORY AVAILABLE AT THIS TIME
CHARGE LIMIT
STATUS
NOTE:-DETAILS IN BRACKETS SHOW MAXIMUM NO.CHARACTERS ALLOWED AND IF OPTIONAL
FILL IN AND PRESS "ENTER," OR "CLEAR" TO CANCEL
Contact Us
Human Resources
Employee Information
Figure 4. A default Web transformation
As you can see, HATS has added a banner across the top of the screen and a
navigation area on the left, but has made minimal changes to the original host
screen. This Web page may not yet be what you want to show to your users. Now
you do some customizations. You change your template. After each modification
you make, you preview the screen to evaluate your changes. Soon your page looks
like this:
4
IBM Rational Host Access Transformation Services: Getting Started
My Company
Credit Application
Products
Corporate
Store Locator
Jobs
Search
Support
Services
Company Links
My Accounts
Credit Request
Complete fields and click Submit
Account number:
55550
Credit type:
Credit limit:
Reset
Last name:
Default
First name:
Refresh
Address:
Disconnect
Birthdate:
Individual
Joint
Student
Submit
Exit
Figure 5. A customized Web transformation
After a very short time, you have transformed the host screen into an attractive
Web page that provides all the function of the host screen and more, and is
accessible through a Web browser. You decided to switch to a template more suited
to your business. You hid unnecessary information, and created a table to display
only required input fields. You provided a drop-down list of valid values for an
input field and use of a calendar widget for another input field. Finally, you
changed the size and location of some of the text and provided navigation buttons.
If you decide to create a portlet, you can generally follow the same steps for
creating a Web application and then use the HATS function to generate a portlet
from a Web application.
If instead of creating a Web application, you decide to create an application that
runs on a rich client platform, you also perform basically the same steps. You use a
wizard to create a simple HATS rich client project. You give your project a name
and specify the host machine where the host application runs. You take all the
defaults and add no customization. After just a few minutes, you use the preview
function to see the host screen transformed to this:
Chapter 1. Introducing Host Access Transformation Services
5
Default Refresh
ACCOUNTS
ADD ACCOUNT NUMBER 55550
SURNAME
FIRST NAME
TELEPHONE
ADDRESS LINE1
LINE2
LINE3
:
:
:
:
:
:
CARDS ISSUED
DATE ISSUED
APPROVED BY
:
:
:
:
(18 CHRS) TITLE
(12 CHRS) MIDDLE INIT:
(10 DIGS)
(24 CHRS)
(24 CHRS)
(24 CHRS OPTIONAL)
(1 TO 9)
(MM DD YY)
(3 CHRS)
CARD CODE :
REASON CODE:
(4 CHRS OPTIONAL)
(1 CHR OPTIONAL)
(1 CHR)
(N,L,S,R)
UPTO 4 OTHERS WHO MAY CHARGE (EACH 32 CHRS OPTIONAL)
01:
02:
03:
04:
(EACH 1 CHR OPTIONAL)
SPECIAL CODE1: CODE2: CODE3:
NO HISTORY AVAILABLE AT THIS TIME
CHARGE LIMIT
STATUS
NOTE:-DETAILS IN BRACKETS SHOW MAXIMUM NO.CHARACTERS ALLOWED AND IF OPTIONAL
FILL IN AND PRESS "ENTER," OR "CLEAR" TO CANCEL
3: 17
Figure 6. A default rich client transformation
As you can see, HATS has added a banner down the left side of the page, but has
made minimal changes to the original host screen. This GUI may not yet be what
you want to show to your users. Now you do some customizations. You change
your template. After each modification you make, you preview the screen to
evaluate your changes. Soon your transformation looks like this:
Default Refresh
Credit Request
Complete fields and click Submit
Account number: 55550
Credit type:
Credit limit:
Last name:
First name:
Individual
Joint
Student
Address:
Submit
Exit
3: 17
Figure 7. A customized rich client transformation
After a very short time, you have transformed the host screen into an attractive
GUI that provides all the function of the host screen and more, and is accessible
using a rich client application. You decided to switch to a template more suited to
your business. You hid unnecessary information, and display only required input
6
IBM Rational Host Access Transformation Services: Getting Started
fields. You provided a drop-down list of valid values for an input field, changed
the size and location of some of the text, and provided navigation buttons.
Whether creating a Web application or a rich client application, you might decide
that this is enough customization, but with HATS you can add much more. For
example, you can:
v Use HATS macro support to provide programmed navigation through multiple
host screens. For example, you can take your users directly to the first screen
that you want them to use, bypassing other screens. You can use macros or the
screen combination function to combine data from several host screens into one
HATS GUI page.
v Use business logic and global variables to integrate your host applications with
other back-end systems in your enterprise, as well as with your business
partners' systems.
v From HATS macros generate HATS Integration Objects, which are Java beans
that encapsulate interactions with a host application, and use them to create Web
pages, Web services support files, or RESTful service JAX-RS resources.
v Develop Enterprise JavaBeans components that use HATS Integration Objects to
exchange data with host applications.
v Develop a HATS Web application with an interface that allows users to access
your host system using mobile devices such as cellular phones, data collection
terminals, and personal digital assistants (PDAs).
v Develop a HATS portlet, which complies with either the standard Java Portlet
Specification (JSR 168 or JSR 286) API or the IBM Portlet API, and deploy it on
WebSphere Portal.
How to add these and other types of customization is discussed in the remainder
of this book and in the HATS User's and Administrator's Guide.
A HATS 5250 example
Imagine you need to create a GUI for a 5250 host application. With HATS you
have a choice of providing the GUI using a Web application (including portlets) or
a rich client application. For more information about the use of HATS portlets and
rich client applications, including advantages, considerations, and limitations, see
the WebSphere Portal and HATS chapter and the Rich client platform and HATS
chapter in the HATS User's and Administrator's Guide.
The following figure shows a screen from the host application:
Chapter 1. Introducing Host Access Transformation Services
7
Find Data in Query Manager Table
Table..........:
Description....:
CATALOG
Product Catalog
Type search conditions, press Enter.
No conditions entered will find all data.
AND,OR,
(,)
(__
__
__
__
__
__
__
__
)
Column
Test
Value
_________
_________
_________
_________
_________
_________
_________
_________
____
____
____
____
____
____
____
____
______________
______________
______________
______________
______________
______________
______________
______________
Bottom
F3=Exit
F14=Delete line
F4=Prompt
F6=Insert line
F20=Display entire name
F10=Copy line
F12=Cancel
F22=QM Statement
MA* a
12/013
Figure 8. A host terminal screen
If you need to create a Web application that provides the GUI, you use a wizard to
create a simple HATS Web project. You give your project a name and specify the
host machine where the host application runs. You take all the defaults and add no
customization. After just a few minutes, you use the preview function to see the
host screen transformed to this:
My Company
Innovative technologies designed for the future
Home
My Company Home Page
My Company Map
My Company Employees
Jobs at My Company
My Company Articles
Support
Reset
Default
Refresh
Disconnect
Turn Keyboard Off
About My Company
Links
Stock Quote
Find Data in Query Manager Table
Table..........:
Description....:
CATALOG
Product Catalog
Type search conditions, press Enter.
No conditions entered will find all data.
AND,OR,
(,)
Column
Test
Value
Bottom
F3=Exit
F14=Delete line
F4=Prompt
F6=Insert line
F20=Display entire name
Contact Us
F10=Copy line
F12=Cancel
F22=QM Statement
Human Resources
Employee Information
12/013
Figure 9. A default Web transformation
As you can see, HATS has added a banner across the top of the screen and a
navigation area on the left, but has made minimal changes to the original host
screen. This Web page is not yet what you want to show to your users. Now you
do some customization. After each change you make, you preview the screen to
evaluate your changes. Soon your page looks like this:
8
IBM Rational Host Access Transformation Services: Getting Started
My Company
Sales and Distribution
Products
Services
My Accounts
Support
Company Links
Corporate
Store Locator
Jobs
Search
Product Catalog
Select search value and click Submit
Reset
Submit
Exit
Default
Refresh
Disconnect
Animals
Sports
Toddler Toys
Figure 10. A customized Web transformation
After a very short time, you have transformed the host screen into an attractive
Web page that provides all the function of the host screen and more, and is
accessible through a Web browser. You decided to switch to a template more suited
to your business. You hid unnecessary information and display only required input
fields. You inserted some data on the screen to aid the user in constructing correct
search conditions, provided a drop-down list of valid values for an input field,
changed the size and location of some of the text, and provided navigation
buttons.
If instead of creating a Web application, you need to create an application that runs
on a rich client platform, you perform basically the same steps. You use a wizard
to create a simple HATS rich client project. You give your project a name and
specify the host machine where the host application runs. You take all the defaults
and add no customization. After just a few minutes, you use the preview function
to see the host screen transformed to this:
Chapter 1. Introducing Host Access Transformation Services
9
Exit
Prompt
Insert line
Copy line
Cancel
Delete line
Display entire name
QM Statement
Default Refresh
Find Data in Query Manager Table
Table..........:
Description....:
CATALOG
Product Catalog
Type search conditions, press Enter.
No conditions entered will find all data.
AND,OR,
(,)
Column
Test
Value
Bottom
12:13
Figure 11. A default rich client transformation
As you can see, HATS has added a banner down the left side of the page, but has
made minimal changes to the original host screen. This GUI is not yet what you
want to show to your users. Now you do some customization. After each change
you make, you preview the screen to evaluate your changes. Soon your
transformation looks like this:
Default Refresh
Product Catalog
Select search value and click Submit
Submit
Exit
Exit
Animals
Sports
Toddler Toys
3: 17
Figure 12. A customized rich client transformation
After a very short time, you have transformed the host screen into an attractive
GUI that provides all the function of the host screen and more, and is accessible
10
IBM Rational Host Access Transformation Services: Getting Started
using a rich client application. You decided to switch to a template more suited to
your business. You hid unnecessary information and display only required input
fields. You inserted some data on the screen to aid the user in constructing correct
search conditions, provided a drop-down list of valid values for an input field,
changed the size and location of some of the text, and provided navigation
buttons.
Whether creating a Web application or a rich client application, you might decide
that this is enough customization, but with HATS you can add much more. For
example, you can:
v Use HATS macro support to provide programmed navigation through multiple
host screens. For example, you can take your users directly to the first screen
that you want them to use, bypassing other screens. You can combine data from
several host screens into one HATS GUI page.
v Use business logic and global variables to integrate your host applications with
other back-end systems in your enterprise, as well as with your business
partners' systems.
v From HATS macros generate HATS Integration Objects, which are Java beans
that encapsulate interactions with a host application, and use them to create Web
pages, Web services support files, or RESTful service JAX-RS resources.
v Develop Enterprise JavaBeans components that use HATS Integration Objects to
exchange data with host applications.
v Develop a HATS Web application with an interface that allows users to access
your host system using mobile devices such as cellular phones, data collection
terminals, and personal digital assistants (PDAs).
v Develop a HATS portlet, which complies with either the standard Java Portlet
Specification (JSR 168 or JSR 286) API or the IBM Portlet API, and deploy it on
WebSphere Portal.
How to add these and other types of customization is discussed in the remainder
of this book and in the HATS User's and Administrator's Guide.
What's new in HATS
New supported environments
Application development and runtime environments
HATS V9.0 extends the supported application development environment to
Rational SDP V9.0. New HATS runtime environments include WebSphere
Application Server V8.5.5 and Eclipse V4.2.
HATS V9.0 does not support Rational SDP V8.5 or WebSphere Application Server
V6.1.
Note: For the current list of prerequisites, see “Prerequisites” on page 23.
For up-to-date support considerations, see "Rational Host Access Transformation
Services 9.0 - Known issues and workarounds" at http://www.ibm.com/support/
docview.wss?rs=3441&uid=swg27038663.
Oracle WebLogic Server
With HATS V9.0 you can develop, test, and deploy HATS web applications
targeted for Oracle WebLogic Server.
Chapter 1. Introducing Host Access Transformation Services
11
For more information, see Developing HATS applications for Oracle WebLogic
Server in the HATS User's and Administrator's Guide.
Ease of use
Macro content assistance
You can now use content assistance while editing a macro on the Source tab of
either the Macro Editor or the Visual Macro Editor. Press Ctrl+Space to invoke
content assistance. By default, content assistance is enabled for all macros in the
project. You can configure which macros in the project provide content assistance.
For instructions, see Macro Content Assistance.
The following ease of use function was added to HATS through a fix pack to the
previous release. It is now integrated into HATS V9.0.
ID attribute for input fields
Along with the name attribute, the id attribute is added to all input fields in HATS
transformations.
Coexistence
HATS V6, V7.0, V7.1, V7.5, V8.0, and V8.5 can coexist, within their own
individually supported Rational SDP offerings, on the same development system
with HATS V9.0. It is also possible for HATS V9.0 to be installed multiple times on
the same system. If you have multiple supported Rational SDP offerings installed
on your system, HATS V9.0 can be installed into each of them.
Migration
If you are a Host Publisher V4, HATS V5, V6, V7.0, V7.1, V7.5, V8.0, or V8.5 user,
you can migrate your projects to HATS V9.0.
HATS V4 LE, HATS V5 LE, and HATS V4 projects cannot be migrated directly to
HATS V8.0, V8.5, or V9.0. To migrate these projects you must first migrate them to
an interim release of HATS, for example, V5, V6, V7, V7.1, or V7.5, and then
migrate them from the interim release to HATS V8.0, V8.5, or V9.0. See the
documentation for your previous release of HATS for information about migrating
HATS projects.
For more information about migrating to HATS V9.0, see the HATS User's and
Administrator's Guide
Serviceability
IBM Support Assistant
The IBM Support Assistant (ISA) can help you simplify software support, reduce
support costs, and improve your ability to resolve software problems in-house
quickly. ISA is a free local software serviceability workbench that helps you resolve
questions and problems with IBM software products. For more information see the
ISA Web site at http://www.ibm.com/software/support/isa/.
HATS provides a plug-in for ISA V4.x. The HATS plug-in provides links to the
HATS Information Center, home page, support site, education assistant site, and
other sites. You can search these sites for information that may help you resolve a
12
IBM Rational Host Access Transformation Services: Getting Started
problem. For information about how to install the HATS plug-in, see the section,
Use the IBM Support Assistant, in HATS Troubleshooting.
Roles and skills
A number of different people, each with different roles within your organization,
can be users of HATS. Depending on the role, skills ranging from a beginning user
to an advanced developer may be required. The following roles and skills are
involved in HATS application development, deployment, administration, and
usage:
Casual Web developer
A user of the HATS Toolkit. The developer creates and edits a HATS Web
application using Rational SDP and the HATS perspective.
Skills expected:
Creating a default application may require minimal HTML, JSP, and
cascading style sheet (CSS) skills. Editing transformations and templates
may require minimal to advanced HTML, JSP, CSS, and JavaScript skills.
Advanced Web developer
A HATS Toolkit user who is already familiar with Rational SDP and advanced
topics such as servlets, EJBs, Struts, JSF, and Web services. The developer creates
and edits a HATS Web application using Rational SDP and the HATS perspective.
The developer also creates business objects (Integration Objects) based on HATS
macros, and integrates these with other back-end systems.
Skills expected:
Highly skilled in HTML, JSP, CSS, JavaScript, and Java EE application
environments.
Casual rich client developer
A user of the HATS Toolkit. The developer creates and edits a HATS rich client
application using Rational SDP and the HATS perspective.
Skills expected:
Creating a default application may require minimal Java skills. Editing
transformations and templates requires skills using the Java Editor or
Visual Editor and minimal to advanced Java skills.
Advanced rich client developer
A HATS Toolkit user who is already familiar with Rational SDP and advanced
topics such as SWT widgets and Eclipse plug-ins. While creating and editing a
HATS rich client application using Rational SDP and the HATS perspective, the
developer might create custom components and widgets, integrate business logic,
and create custom perspectives.
Skills expected:
Highly skilled in Java, SWT, and Eclipse plug-in development.
User
HATS has two types of users. The browser-based user and the rich client-based
user of a HATS application. The browser-based user invokes the application, either
through a direct URL request to the application or through a portal, and uses the
Chapter 1. Introducing Host Access Transformation Services
13
resulting host session to work with a host application. The rich client-based user
clicks an icon that will establish a host session.
Skills expected:
Web browser or rich client platform common usage is all that is required.
HATS administrator
The person who administers HATS Web applications including portlets. This may
be the same person as the WebSphere Application Server administrator or the
WebSphere Portal administrator. This person has the ability to monitor the number
of HATS sessions and manually stop connections in error cases. Currently, this role
only exists for the HATS Web application and portlet environments.
Skills expected:
Web browser common usage along with HATS problem determination
skills.
WebSphere administrator
The person who administers WebSphere Application Server. The WebSphere
administrator is responsible for deploying HATS applications that have been
packaged as .ear files and transferred to the production system. This role exists for
the HATS Web application environment.
Skills expected:
Web browser common usage along with HATS and WebSphere Application
Server problem determination skills.
Rich client administrator
The person responsible for installing, provisioning, and deploying HATS rich client
applications.
Skills expected:
Skills with maintaining update sites along with rich client platform and
HATS problem determination skills.
WebFacing developer
The user of the IBM WebFacing Tool for IBM i feature. Using Rational SDP and the
WebFacing perspective, the WebFacing developer creates and edits a WebFacing
application to convert IBM i data description specification (DDS) display file source
members into a Web-based user interface for 5250 programs.
Skills expected:
Creating an application requires knowledge of the location of the DDS
source required by the 5250 program; customizing the Web interface may
require HTML, JSP, CSS, and JavaScript skills.
Independent software vendors
Independent software developers use the HATS Toolkit to create custom
applications that are resold to other customers.
14
IBM Rational Host Access Transformation Services: Getting Started
Accessibility
Accessibility features help a user who has a physical disability, such as restricted
mobility, limited vision, or other special needs, to use software products
successfully. As a set of plug-ins of Rational SDP, HATS takes advantage of the
accessibility capabilities provided by Rational SDP. These are the major accessibility
capabilities in Rational SDP:
v Rational SDP uses Microsoft Active Accessibility (MSAA) APIs to render user
interface elements accessible to assistive technology.
v You can operate all features using the keyboard instead of the mouse.
Note: On some systems you may not see the underline indicators for all of the
accelerator keys on the subfile component settings page. This is the page
accessed from Project Settings > Rendering > Components > Subfile >
Settings. If this is the case on your system, to see all of the underline
indicators use the Alt+s keys to access the page instead of clicking the
Settings button.
v You can use screen-reader software such as Freedom Scientific's Job Access With
Speech (JAWS) and a digital speech synthesizer to recognize what is displayed
on the screen audibly.
v You can magnify what is displayed on your screen in the graphical views.
v Any colors or fonts defined by Rational SDP can be set using the Window >
Preferences > General > Appearance > Colors and Fonts dialog.
Accessibility when using HATS
Keep the following in mind when using HATS:
v Some configuration might be required to use a screen reader to read the host
screen. For example, you may need to select the option Close default rendering
table data and row tags in the Advanced rendering project settings. For more
information see HTML tables in the Advanced rendering section in the HATS
User's and Administrator's Guide.
v HATS initially gives focus to the host transformation area when the HATS
application begins. However, if you have a template with navigational links
across the top or down the left side, you may want to add at the beginning of
the template a link to the beginning of the host transformation area. The
purpose of this link is to enable users to quickly bypass all the navigational links
to get to the main content of the host page. In the templates supplied by HATS
is example code (commented out) to provide such a link. Refer to the source for
these templates for an example.
v The HATS preference, Alert recognition errors with audible alarm, allows you
to specify that an audible alert (beep) be played when there is a recognition
error, for example, on the Subfile component settings page. This is useful if the
developer must be alerted to use screen reader software to read the message
area. For information about where to set this preference, see the Using HATS
Preferences section in the HATS User's and Administrator's Guide.
v You must install the Java Access Bridge to use assistive technologies with the
advanced macro editor. Follow the instructions provided with the Java Access
Bridge to configure the JVM in which the advanced macro editor runs. For
example, in Rational Application Developer, configure the accessibility.properties
file typically located in the following path: <RationalSDP_install_directory>\jdk\
jre\lib.
Chapter 1. Introducing Host Access Transformation Services
15
v If the screen reader encounters difficulty in reading some of the contents of an
editor panel, you can switch to another perspective or reconfigure the screen
reader.
v When using JAWS while working in a HATS project, JAWS may instruct you to
use CTRL+TAB to move across pages. If this key sequence does not work within
the HATS toolkit, use the left and right arrow keys to move the focus from tab
to tab.
v The 5250 Subfile component settings wizard displays four tabs, Action, Header,
Data, and Marker. Each tab is used to define the criteria for recognizing a
particular element of the subfile. Icons on each tab indicate whether the element
is recognized, unrecognized, or unknown. When using JAWS, these icons are
voiced using their graphics character number. You can use the JAWS Graphics
Labeler to assign labels to these icons as shown below:
– Graphics 58: Unrecognized
– Graphics 362: Unknown
– Graphics 706: Recognized
Notes:
1. HATS supports accessibility for Web applications only when using Internet
Explorer.
2. HATS supports accessibility for rich client applications in both the application
and transformation views.
Keyboard shortcuts
Ctrl + F9
When a region of the host screen is selected, a new dialog box opens up
that displays the selected text.
Where can I find more information about accessibility?
For more information about accessibility, refer to the following Web sites:
v WebFacing Accessibility at http://pic.dhe.ibm.com/infocenter/hatshelp/v90/
index.jsp?topic=/com.ibm.hats.doc/doc/topics/accessibility.html.
v W3C Web Content Accessibility Guidelines 2.0 at http://www.w3.org/TR/
WCAG20/.
v W3C Techniques for WCAG 2.0 at http://www.w3.org/TR/WCAG20-TECHS/.
v IBM Developer guidelines for Web accessibility at http://www-03.ibm.com/
able/guidelines/web/accessweb.html.
v IBM Web accessibility checklist at http://www-03.ibm.com/able/guidelines/
web/ibm508wcag.html.
Where can I find information about HATS?
The following HATS information is available before you install HATS:
v HATS documentation is available on the HATS installation CD. From the
installation launchpad, select links to the following documents:
– Release Notes
– Getting Started (pdf)
v The HATS Information Center at http://pic.dhe.ibm.com/infocenter/hatshelp/
v90/index.jsp includes information from the Release Notes, frequently asked
questions (FAQs), API reference information, tutorials, WebFacing information,
and HTML and PDF versions of the documents listed below. Available translated
PDF versions are also included.
16
IBM Rational Host Access Transformation Services: Getting Started
–
–
–
–
–
HATS
HATS
HATS
HATS
HATS
Getting Started
User's and Administrator's Guide
Web Application Programmer's Guide
Rich Client Platform Programmer's Guide
Advanced Macro Guide
– HATS Messages
– HATS Troubleshooting
– Developing WebFacing Applications
v The HATS product Web site at http://www.ibm.com/software/products/us/
en/rhats includes additional product information such as feature overview, trial
download, system requirements, and more.
v The HATS HotSpot at https://www.ibm.com/developerworks/
mydeveloperworks/groups/service/html/
communityview?communityUuid=2ce1fd8d-d706-4afd-b9ef-9000ad21218d
includes a resource library, discussion forums, blogs, and more.
v The IBM Education Assistant Web site at http://publib.boulder.ibm.com/
infocenter/ieduasst/rtnv1r0/index.jsp integrates narrated presentations,
demonstrations, tutorials, and resource links to help you successfully use IBM
products. Search for Host Access Transformation Services in the Contents.
In addition to the information available before installing HATS, the following
information is available on the system after installing HATS:
v Links to the HATS Web site, Information Center, and Release Notes are available
on the Windows Start menu.
v HATS documentation, including WebFacing, is available from the Help menu on
the Rational SDP menu bar. Select Help > Help Contents and in the Contents
panel select Developing HATS Applications.
v The HATS Welcome page tutorial guides you through the process of developing
a HATS application, and if installed on the IBM Rational Developer for Power
Systems Software™ product, introduces the IBM WebFacing Tool for IBM i
feature of the HATS Toolkit.
v If the WebFacing Tool is installed, the WebFacing Welcome page tutorial
provides information similar to the HATS Welcome page tutorial.
v Context-sensitive help is available on all fields in the HATS wizards and editors.
Press the F1 key to see help in the HATS Toolkit.
v Tips are provided at key points in the process of developing a HATS project.
You can control whether you want to see tips by modifying HATS preferences.
Chapter 1. Introducing Host Access Transformation Services
17
18
IBM Rational Host Access Transformation Services: Getting Started
Chapter 2. Introducing the WebFacing Tool
The WebFacing Tool for IBM i is available as an optionally installable feature of the
HATS Toolkit.
While this manual is primarily about installing HATS, the WebFacing Tool is
referenced in the HATS library.
v “Installing HATS Toolkit” on page 24 in this manual
v WebFacing and HATS in HATS User's and Administrator's Guide
What is WebFacing?
The IBM WebFacing Tool for IBM i converts existing 5250 user interfaces to
Web-based graphical user interfaces. With little or no modification to your original
IBM i applications, you can extend the use of your programs to anywhere that
users have access to a browser.
WebFacing features
WebFacing has user-friendly wizards that facilitate selecting your original
application's data description specifications (DDS) and user interface manager
(UIM) help panel source members, converting the source, and deploying the new
browser-based interface to your program as a Web application. The conversion
creates JavaServer Pages (JSPs) and Extensible Markup Language (XML) files for
your display files and make Web access possible.
Customization
Using the provided tools in the WebFacing perspective, you can further enhance
the graphics, fonts, colors, and layouts of your Web pages. For example, you can
use Web Settings to customize how your application renders and functions when
accessed through a Web browser. Customizations through Web Settings are
embedded as comments in your DDS, and are still effective should you later
reconvert the source. Cascading Style Sheet Positioning is one of the Web Settings
available to you. This allows DDS fields on the Web-enabled interface to be
repositioned, unconstrained by the boundaries of the original 5250 area, and is a
powerful way to customize the interface.
© Copyright IBM Corp. 2002, 2013
19
Figure 13. Working with projects in the WebFacing perspective
Zero OLTP
Your WebFacing application can be run without requiring Online Transaction
Processing (OLTP) capacity. System screens and unconverted parts of your
application can also be displayed by WebFacing through dynamic transformation
of the screens.
Portal
The WebFacing Tool can generate a portlet application that can be deployed to a
WebSphere Portal server and added to the portal pages served by that server. This
allows multiple applications to run in the same browser window. Portlet
applications can also take advantage of the features available to a WebFacing Web
project.
20
IBM Rational Host Access Transformation Services: Getting Started
Figure 14. WebFacing application running on a portal server with other portlets
Single sign-on
WebFacing applications also support single sign-on, which enables users to access
more than one application and multiple platforms without having to sign on
multiple times. For example, you can integrate secured WebFacing and other Web
applications that a user can access without requiring separate IDs and passwords
for each application, or you can access a WebFacing portlet without signing on
again after you have signed on to the portal.
WebFacing and HATS interoperability
The WebFacing and HATS interoperability feature enables you to easily integrate
your WebFacing and HATS Web applications when running on the Web. You can
create a HATS/WebFacing enabled project with the WebFacing Tool and link it
with a HATS project. This linked HATS/WebFacing application operates seamlessly
and provides a unified, Web-enabled interface, which can be deployed to a
WebSphere Application Server. It utilizes the capabilities of both HATS and the
WebFacing Tool. For more information about interoperability between HATS and
WebFacing, see WebFacing and HATS in HATS User's and Administrator's Guide.
Chapter 2. Introducing the WebFacing Tool
21
Application bridge
The application bridge is of great value when enhancing your IBM i application by
allowing you to implement part of it as a Web application, for example, using
Enterprise Generation Language (EGL) to create a new Web application, and
modernizing other parts of your application with WebFacing or HATS. It allows
WebFacing to transfer control and data to and from other Web applications, such
as one written in EGL, giving you the ability to combine HATS, WebFacing, and
EGL into a single, modernized, integrated application.
IBM i integrated Web application server
WebFacing applications can be deployed to the IBM i integrated Web application
server. You can use the IBM i integrated Web application server if you are
deploying WebFacing Web applications and have limited IBM i system resources
that cannot optimally run the WebSphere Application Server. Note that this
configuration does not support high availability and failover.
High availability and failover
WebFacing provides cluster support on a WebSphere Application Server Network
Deployment (ND) to meet the high availability and server failure bypass needs of
your application, allowing for better response times, scalability, and failover safety.
You can also configure additional interactive subsystems on IBM i to handle a
greater number of simultaneous users of your WebFacing application.
What's new in WebFacing
New supported environments
HATS V9.0 extends the supported application development environment to
Rational SDP V9.0. Supported WebFacing runtime environments now include
WebSphere Application Server V8.5.5.
Where can I find information about WebFacing?
The WebFacing Tool product help is installed when you install the WebFacing
feature during the installation of HATS. For more information see the Developing
WebFacing Applications topic available as part of the product help. WebFacing
information is also available online on the HATS Information Center at
http://pic.dhe.ibm.com/infocenter/hatshelp/v90/index.jsp
22
IBM Rational Host Access Transformation Services: Getting Started
Chapter 3. Installing HATS
With the information in this chapter you can:
v Review hardware and software prerequisites and plan for the installation of
HATS
v Install and uninstall HATS Toolkit on your workstation
v Install and uninstall HATS Toolkit silently
Prerequisites
IBM Installation Manager Version 1.6.3.1, or later, is required to install HATS
Toolkit.
Note: For more about IBM Installation Manager, see the information center at
http://publib.boulder.ibm.com/infocenter/install/v1r6/index.jsp.
When you install HATS V9.0 using the IBM Installation Manager, the installation
process checks that prerequisite packages and features are already installed. If not,
a message is displayed, and the install does not proceed. The following sections list
the prerequisite packages and features that must already be installed.
IBM Rational HATS
For IBM Rational HATS (HATS):
v One of the following Rational SDP packages, or later fixpacks, including the
WebSphere Application Server version 7.0, version 8.0, or version 8.5
development tools features:
– IBM Rational Application Developer for WebSphere Software V9.0
–
–
–
–
IBM
IBM
IBM
IBM
Rational
Rational
Rational
Rational
Business Developer V9.0
Software Architect for WebSphere Software V9.0
Developer for i V9.0
Developer for AIX® and Linux V9.0
If none of the required Rational SDP packages are installed, HATS will not install.
If this occurs, use the Install function of the IBM Installation Manager to install one
of the required packages along with the required features. Then start the HATS
install again.
If one of the required Rational SDP packages is installed without the required
features, HATS will not install. If this occurs, use the Modify function of IBM
Installation Manager to add the required features. Then start the HATS install
again.
IBM WebFacing Tool for IBM i feature
For the IBM WebFacing Tool for IBM i feature (WebFacing):
v IBM Rational Developer for i V9.0, or later fixpacks, including IBM i and
enterprise web developer tools.
Note: The Rational SDP packages must be installed in the same package group.
© Copyright IBM Corp. 2002, 2013
23
If the prerequisites are not satisfied, the WebFacing feature cannot be selected for
installation. If this occurs, use the Install or Modify function, as appropriate, of the
IBM Installation Manager to install the prerequisites. Then use the Modify function
to install WebFacing.
Portal support for IBM WebFacing Tool for IBM i feature
For the Portal support for IBM WebFacing Tool for IBM i feature (Portal for
WebFacing):
v IBM Rational Developer for i V9.0, or later fixpacks, including IBM i and
enterprise web developer tools and WebSphere Portal Server 7.0 or 8.0
development tools features.
v Plus the IBM WebFacing Tool for IBM i feature.
If the prerequisites are not satisfied, the Portal for WebFacing feature cannot be
selected for installation. If this occurs, use the Modify function of IBM Installation
Manager to install the prerequisites. Then use the Modify function to install Portal
for WebFacing.
Other prerequisites
There are other hardware and software prerequisites for the system where you
install HATS Toolkit, the systems where you deploy HATS applications, WebSphere
Application Server, WebSphere Portal, or rich client platform systems, and the
browsers with which your users will interact with HATS Web applications. See
"System Requirements for Rational Host Access Transformation Services" at
http://www.ibm.com/support/docview.wss?uid=swg27011794 for the current list
of supported hardware and software prerequisites.
Installing HATS Toolkit
To install HATS Toolkit:
1. Verify that your system meets all the prerequisites. For more information see
“Prerequisites” on page 23.
2. HATS is structured as an Eclipse offering that is installed to a Rational SDP
system using IBM Installation Manager.
3. If you are installing from a CD and autorun is enabled, then the launchpad
starts automatically when you insert the installation disk into your CD drive.
If autorun is not enabled, or if you are installing from an electronic image, run
the launchpad.exe program located in the root directory of the CD or located
in the root directory of the extracted electronic image of the installation disk.
4. Select the language for the launchpad. Click OK.
5. The IBM Rational HATS V9.0 window appears. From this window you can
install the product and view release information. Be sure to click Release
Notes to review last-minute information.
6. When you are ready to install HATS Toolkit, click Install IBM Rational HATS
V9.0 which launches the IBM Installation Manager.
Note: If IBM Installation Manager is not installed an error message is
displayed.
7. The IBM Installation Manager window appears.
8. On the Install Packages panel, the box for IBM Rational HATS is selected for
you. Click Next.
24
IBM Rational Host Access Transformation Services: Getting Started
Note: An error message is displayed if the required level of IBM Installation
Manager is not installed.
9. On the Licenses panel, read and accept the terms in the license agreement,
and click Next.
10. On the Location panel, under Package Group Name, select the package group
where you want to install HATS, for example IBM Software Delivery
Platform, and click Next.
Note: You must select an existing package group where you have installed the
prerequisite software delivery products.
11. On the Features panel, in addition to HATS, you can select for installation the
following HATS features. Click Next.
v IBM WebFacing Tool for IBM i
Provides the ability to convert IBM i DDS display file source members into
a Web-based user interface for your existing 5250 programs.
– Portal support for IBM WebFacing Tool for IBM i
Provides portal support for the WebFacing feature.
Notes:
a. You can install these features at a later time by using the Modify function
of IBM Installation Manager. For more information see “Modifying the
HATS Toolkit installation” on page 26.
b. For prerequisite information see “Prerequisites” on page 23.
12. On the Summary panel, click Install.
13. You will see a progress bar as the installation proceeds and Start menu items
are created.
14. On the Install Packages panel, you are informed if the installation was
completed successfully. If necessary, you can click View Log File to view the
installation log. Click Finish to close the installation panel.
Notes:
1. All languages supported by HATS and the HATS features are installed during
the installation process.
2. HATS cannot be installed at the same time you install the prerequisite level of
Rational SDP and features. You must complete the installation of the
prerequisite level of Rational SDP and features before installing HATS.
Updating the HATS Toolkit installation
You can install HATS V9.0 fix packs using the update function of the IBM
Installation Manager. By default, Internet access is required unless your repository
preferences point to a local update site.
Note: Earlier versions of HATS cannot be updated to HATS V9.0. To coexist,
earlier versions and HATS V9.0 can be installed in separate package groups.
To update the HATS Toolkit:
1. Start IBM Installation Manager from the Windows Start menu. By default this
is under Start > All Programs > IBM Installation Manager > IBM
Installation Manager.
2. From the menu bar, select File > Preferences.
Chapter 3. Installing HATS
25
3. Ensure that the Search service repositories during installation and updates
option is selected to allow updates from the IBM Update Server. Click OK to
return to the IBM Installation Manager screen.
4. On the initial IBM Installation Manager panel, click Update.
Note: Do not click Install.
5. Select the package group in which you installed IBM Rational HATS V9.0. The
default is IBM Software Delivery Platform. The Installed Packages and Fixes
list at the bottom of the panel should show IBM Rational HATS 9.0.0.x as one
of the entries. Click Next.
6. Select IBM Rational HATS 9.0.0.x and any other required or optional updates
from the list of available updates. Any updates you already have installed will
be displayed in grey and will not be selectable. Click Next.
7. Read and accept the license agreements for the selected updates, and then
follow the remaining installation dialogs to install the selected updates.
Note: Depending on the speed of your computer processor, the amount of
RAM, and the speed of your Internet connection, the update(s) could
take an extended period of time to download and install.
8. Review your selections on the Summary panel. If you want to make any
changes to your selections, click Back and make your changes. When you are
ready to install the update, click Update.
9. When the updates are complete, a message will be displayed by IBM
Installation Manager informing you that updates were successfully installed.
You can click View Log File to view the log file for the current Installation
Manager session. When you are finished, click Finish.
10. Exit IBM Installation Manager and start IBM Rational Host Access
Transformation Services from the Windows Start menu to begin using the
product. By default this is under Start > All Programs > IBM Software
Delivery Platform > IBM Rational Host Access Transformation Services.
Note: For more about fix pack contents and install instructions, see the appropriate
release notes on the HATS Information Center at http://pic.dhe.ibm.com/
infocenter/hatshelp/v90/index.jsp.
Modifying the HATS Toolkit installation
You can use the IBM Installation Manager to modify an already installed HATS
Toolkit. For example, you can add, or remove, any of the HATS features. To add
any of the HATS features, follow these steps:
1. With the HATS CD in the CD-ROM drive or the extracted electronic image of
the HATS installation disk accessible, start IBM Installation Manager.
Note: If the HATS CD or electronic image is not already defined as an
installation repository, see “Adding the HATS installation repository to
IBM Installation Manager” on page 27.
2. On the initial IBM Installation Manager panel, click Modify.
3. On the Modify Packages panel, select the package group where you have
installed HATS and click Next.
4. On the Features panel that list languages, click Next.
Note: All languages supported by HATS and the HATS features are installed
during the installation process.
26
IBM Rational Host Access Transformation Services: Getting Started
5. On the Features panel that lists the features to add or remove, select any of the
following HATS features and click Next.
v IBM WebFacing Tool for IBM i
– Portal support for IBM WebFacing Tool for IBM i
Note: For prerequisite information see “Prerequisites” on page 23.
6. On the Summary panel, click Modify.
7. You will see a progress bar as the installation proceeds.
8. On the Modify Packages panel, you are informed if the installation was
completed successfully. If necessary, you can click View Log File to view the
installation log. Click Finish to close the Modify Packages panel.
Use similar steps to remove any of the HATS features.
Adding the HATS installation repository to IBM Installation Manager
The HATS installation program automatically adds the HATS installation directory
as a repository in IBM Installation Manager. If for any reason you need to
manually add the HATS installation directory as a repository, follow these steps:
1. From the IBM Installation Manager menu bar, select File > Preferences.
2. On the Preferences panel, click the Add Repository button.
3. On the Add a Repository panel, click the Browse button.
4. On the Select a Repository panel, browse to the HATS CD or the extracted
electronic image of the HATS installation disk, in the root directory select the
diskTag.inf file, and click OPEN.
Note: If adding a repository for a local installation of a HATS fix pack, browse
to the directory where you extracted the fix pack installation files. Inside
the directory you will see a hats\updates directory. Change to that
directory, select repository.config, and click Open.
5. On the Add a Repository panel, click OK.
6. On the Preferences panel, click OK.
Uninstalling HATS Toolkit
When you uninstall the HATS package, the HATS Toolkit and all installed features
are uninstalled.
When you uninstall HATS Toolkit, the files for your HATS projects and their
resources are not deleted. If you re-install HATS Toolkit you are able to work with
projects you have previously created. To delete your HATS project files, delete each
project before you uninstall HATS. If you want to delete HATS project files after
uninstalling HATS, go to the workspace directory on the file system and delete the
HATS project files.
To uninstall HATS Toolkit:
1. You must be logged on with Administrator privileges.
2. Close the HATS and WebFacing perspectives and exit from Rational SDP.
Note: When you start Rational SDP, it always tries to reopen the last
perspective that was open. To avoid error messages, before you uninstall
HATS, close the HATS and WebFacing perspectives before you exit
Rational SDP. If HATS or WebFacing were the last perspective open
Chapter 3. Installing HATS
27
when you uninstall HATS, Rational SDP will issue error messages
because it cannot find the files necessary to reopen the perspective. If
this occurs, change the perspective, the errors do not harm anything.
3. Start the IBM Installation Manager from the Start menu.
4. On the IBM Installation Manager panel, click Uninstall.
5. On the Uninstall Packages panel, select the IBM Rational HATS package and
click Next.
6. On the Summary panel, click Uninstall.
7. You will see a progress bar as the installation program uninstalls HATS and the
Start menu items.
8. On the Uninstall Packages panel, you are informed if the uninstallation was
completed successfully. If necessary, you can click View Log File to view the
uninstall log. Click Finish to close the Uninstall Packages panel.
Using silent install and uninstall
You can install or uninstall a product package silently using Installation Manager
in silent installation mode. When you run Installation Manager in silent mode, the
user interface is not available; instead, a response file inputs the commands that
are required to install or uninstall the product package. For more information
about how to generate the response files and use them see the section, Installing
Silently, in the Installation Manager Information Center at http://
publib.boulder.ibm.com/infocenter/install/v1r4/topic/com.ibm.silentinstall12.doc/
topics/c_silent_roadmap.html.
Log files
The install, update, modify, and uninstall processes create log files that you can
examine if an error occurs.
By default, the log files are stored in the c:\Documents and Settings\All
Users\Application Data\IBM\Installation Manager\logs\ directory.
28
IBM Rational Host Access Transformation Services: Getting Started
Chapter 4. Enabling HATS runtime and license settings
You can fully enable the runtimes for HATS Web projects, HATS rich client
projects, and WebFacing projects. To fully enable the runtimes for production in
accordance with your licensed proof of entitlement, you must specify your license
settings using the License Settings wizard included in the HATS Toolkit.
Note: You must run the License Settings wizard even for projects whose runtimes
were fully enabled in previous versions of HATS.
To run the License Settings wizard, follow these steps:
1. Start the HATS Toolkit.
2. In the HATS perspective, from the menu bar select HATS > License Settings.
In the WebFacing perspective, right-click anywhere in the WebFacing Projects
view and select License Settings.
3. On the Runtime Enablement File panel, if the location of the runtime
enablement file is not already set from a previous use of the wizard, use the
Browse button to browse for the location of the file.
Notes:
a. The runtime enablement file is provided to you on a CD (or image, if you
downloaded HATS electronically) separate from the HATS Toolkit.
b. If you downloaded HATS from the Passport Advantage® Web site, the
runtime enablement file is located in the runtime enablement CD image.
c. If you cannot locate your runtime enablement file, contact your IBM
business partner or IBM sales representative, as appropriate. IBM technical
service representatives cannot provide you the file. For more information
see http://www-01.ibm.com/support/docview.wss?uid=swg21316632.
d. The name of the runtime enablement file used to fully enable HATS Web,
HATS rich client, and WebFacing projects is runtimeenablement85webrcp.jar. The wizard enables both the HATS and WebFacing runtimes in
one step.
e. You must use the file intended for use with your version of HATS. An error
message will display if during this process you try to use a file for an older
version of HATS.
4. After setting the location of the runtime enablement file, click Next.
5. On the License Options panel the types of projects are displayed with an
indication whether they will be enabled or not enabled based on the selected
runtime enablement file. Select the license option specified by your Proof of
Entitlement. Options are Authorized User or Value Unit. If you specify
Authorized User, you must also enter the number of licenses purchased.
6. Select Apply to all new projects created in any workspace to fully enable the
runtime for all new projects, depending on your type of license, created in any
workspace.
7. Select Apply to all existing projects in the current workspace to fully enable
the runtime for all projects, depending on your type of license, that exist in the
current workspace. If you have existing projects in other workspaces, you must
run the License Settings wizard in each of those workspaces.
© Copyright IBM Corp. 2002, 2013
29
Note: HATS checks the license settings of projects in a workspace on startup
and prompts you to update the license settings if any of the projects
don't match the master license settings. For information about how to
disable checking the license settings at startup, see the HATS User's and
Administrator's Guide.
8. Click Finish.
Evaluating HATS
Regardless of where you obtain the HATS package (HATS CD, Web, or packaged
with another product), you install the same version of the HATS Toolkit. This is a
limited-use version that you can use to evaluate HATS. After installation, you must
use the License Settings wizard in the HATS Toolkit to fully enable the HATS
runtime for production in accordance with your licensed proof of entitlement.
Before purchasing runtime licenses, you can evaluate HATS with minimal
restrictions. You can use the HATS Toolkit to develop applications and test them
using the local test environments.
HATS Web applications that you develop before you fully enable the HATS
runtime are restricted to just two runtime host connections. HATS rich client
applications that you develop before fully enabling the HATS runtime allow
unlimited host connections in the local test environment but no host connections in
a deployed production environment.
After evaluating the HATS Toolkit, if you decide you want to purchase HATS
licenses for runtime deployment, you can fully enable the runtime using the
License Settings wizard without reinstalling the HATS Toolkit.
30
IBM Rational Host Access Transformation Services: Getting Started
Chapter 5. Creating a basic HATS project
Your company has character-based 3270 or 5250 applications (host applications)
and has decided to provide an easy-to-use graphical user interface (GUI) for those
applications. This involves creating new applications that exchange data with the
host and can be accessed by users through either a Web browser or a rich client
platform application. HATS protects your company's investment in its host
applications while customers, business partners, and employees can access them
easily using a modern GUI.
You have been assigned the task of creating a new application that provides a GUI
for a host application. HATS gives you the tools you need to do the job.
The information in this chapter gets you started. By following the procedure in this
chapter, you will create a simple, working HATS application that uses default
values provided with the product. This chapter contains:
v Introductory information that is helpful to understand as you create your
application:
– “Introducing the Rational SDP environment”
– “Introducing the HATS Welcome page” on page 33
v A step-by-step procedure: “Developing a HATS project” on page 36
After completing this chapter, you can update or customize the application to
make it fit the specific needs of your business.
Introducing the Rational SDP environment
All of the steps in developing a HATS application are performed using the
Eclipse-based IBM Rational Software Delivery Platform (Rational SDP). The
Rational SDP provides the user interface and integrated development environment
(IDE) from which you launch wizards to create resources, view lists of resources,
and use editors to modify resources. It also contains help information about both
HATS and Rational SDP.
When you start Rational SDP, you see a single window in which one or more
perspectives are displayed. A perspective is a collection of views and editors that
allow you to create, edit, view, and run resources which belong to a specific type
of project—in this case a HATS project. More than one perspective can be open at a
time, although you can view and work with only one at a time.
At the far right of the Rational SDP window is a shortcut bar that allows you to
open new perspectives and move between perspectives that are already open. The
name of the active perspective appears in the title of the window, and the toolbar
contains icons associated with the active perspective.
If you are not familiar with the Eclipse-based Rational SDP environment, refer to
the Eclipse Help site at http://help.eclipse.org/ganymede/index.jsp. Start with the
Basic tutorial in the Getting started section of the Workbench User Guide.
Starting HATS Toolkit and perspective
The HATS Toolkit can be started two ways.
© Copyright IBM Corp. 2002, 2013
31
v Start Rational SDP from the Windows start menu and then open the HATS
perspective.
v Start HATS Toolkit from the Windows start menu to start Rational SDP and
automatically open the HATS perspective.
Notes:
1. The HATS Toolkit start menu item is located in the IBM Rational HATS V8.5
group under the Rational SDP profile in which you have installed HATS.
2. When you use the HATS Toolkit start menu item, the HATS Toolkit starts in
the language installed for Rational SDP, assuming the HATS Toolkit is
translated in the same language. When installed on an Arabic translation of
Rational SDP, two HATS Toolkit start menu items are provided, HATS
Toolkit (Arabic), which starts the Arabic translation of HATS Toolkit, and
HATS Toolkit (English), which starts the English translation of HATS
Toolkit. For more information see the chapter, Language support, in the
HATS User's and Administrator's Guide.
The HATS perspective includes two main areas:
v The HATS Projects view, which lists your HATS projects in an expandable tree
view.
A text filter entry field is provided to aid you in searching for HATS artifacts.
An asterisk (*) can be used as a wild card to represent parts of the resource
name. For example, using a filter of *.css or *css returns the same matches.
Notes:
1. A wildcard is appended to the end of the text that you enter into the filter
field. For example, if you enter *.j in the filter field, an asterisk is appended
to the *.j, resulting in a filter of *.j*. This filter would show you all .jsp and
.jpg files.
2. Filtering is not case-sensitive.
3. To clear the text in the filter field, click the x beside the filter entry field.
v The editor window, which initially contains the HATS Welcome page. You will
also use editors in this window to work with HATS resources. Below and to the
right of the editor are views that aid in editing resources in the editor.
The Navigator view, which is a default view in Rational SDP, provides a
hierarchical view of the resources in the workbench including project .ear files and
other local artifacts. It also displays closed (or archived) HATS projects that do not
display in the HATS Projects view. These closed projects can be re-opened by
right-mouse clicking and selecting Open Project.
The first time you start the HATS Toolkit, you will see a HATS tip, welcoming you
to HATS and giving pointers about getting started. You can use the check boxes on
the tip windows to control which tips you see.
If you start Rational SDP and the HATS perspective does not appear, you can open
the HATS perspective by clicking Window > Open Perspective > Other and
selecting Host Access Transformation Services from the list of available
perspectives. If you close or rearrange some of the windows in the HATS
perspective, your arrangement is saved when you exit. When you return to HATS
Toolkit, it will be restored to your last successfully saved exit configuration. To
restore the original HATS windows, click Window > Reset Perspective.
32
IBM Rational Host Access Transformation Services: Getting Started
Introducing the HATS Welcome page
The HATS Welcome page tutorial guides you through the process of developing a
HATS application. As you develop the application and customize it, it is known as
a project. A project is then packaged as an application for a production runtime
environment.
A project for a Web application is packaged in a Java EE web module (.war file)
and one or more web modules are packaged in a Java EE Enterprise Application
(.ear file), which is a WebSphere application. The application is transferred to and
installed on a WebSphere Application Server system.
A project for a portlet is packaged in a Java EE web module (.war file) and
transferred to and installed on a WebSphere Portal system.
A project for a rich client application is packaged as a plug-in in an Eclipse feature
which is uploaded to an update site from which it can then be downloaded by
clients on rich client platforms.
Sections on the Welcome page can be expanded by clicking the plus sign icon (+).
Each section contains links that start HATS functions and represents a stage in the
process. A section is also provided that contains links to online information,
1. Create your first project links to the Create a Project wizard and introduces
the Debug on Server (for Web applications) and Debug (for rich client
applications) testing modes, which enable you to preview and test your
project. The testing function is described in detail in “Testing your project” on
page 38. A link to the License Settings dialog is also provided. License settings
must be configured to enable your application for the runtime environment.
2. Modify the template helps you update the template you chose as your project
default.
3. Edit the default rendering set and global rules describes the conversion rules
used by the default transformation, and provides information on the use of
global rules.
4. Customize a screen introduces the host terminal screen and the Create a
Screen Customization wizard. You can create a simple transformation to see
how it changes your host screen.
5. Combine screens introduces the Create a Screen Combination wizard. You can
create a simple screen combination that collects information from a series of
host screens and presents the results as one page.
6. Work with macros, Integration Objects and Web services (SOA) explains
how macros can be used in your projects, and introduces Integration Objects.
Integration Objects, supported in HATS Web applications, are standard Java
beans that play macros. You can create Integration Objects from macros in
your projects and create Web services from Integration Objects. Integration
Objects can also be used in EJB projects.
7. Interoperate with WebFacing introduces the IBM WebFacing Tool for IBM i
feature of the HATS Toolkit. This feature provides the ability to convert data
description specification (DDS) display file source members into a Web-based
user interface for your existing IBM i programs. Links are provided to the
Create Linked HATS/WebFacing project wizard and to the WebFacing
perspective and WebFacing Help. This section is only displayed if the
WebFacing feature of HATS is installed.
Chapter 5. Creating a basic HATS project
33
8. Utilize host simulation describes the function that lets you work on your
HATS project without requiring an active connection to the host. You can
record host simulation trace files that can be saved and then used later instead
of a live host connection.
9. Explore advanced functions of HATS deepens your knowledge about basic
HATS concepts and introduces the project editor, capturing screens,
administration, the connection editor, and more.
10. Prepare your project for production shows you how to export the project as a
WebSphere application (for Web projects) or as an Eclipse feature (for rich
client projects).
11. View the library of online information for HATS provides links to the HATS
documentation, the HATS product Web site, the HATS Information Center, the
IBM Education Assistant, and the IBM Support Assistant.
As you use other HATS functions, focus switches from the Welcome page to
editors or other tools. Each page in the editor window is given a tab at the top to
enable you to move from one page to another. You can return to the Welcome page
by clicking the Welcome to HATS tab, or by clicking the Open HATS Welcome
page icon on the main toolbar. You can double-click any tab to toggle that tab's
page between its initial size and a full-screen view.
A welcome page for the WebFacing component of the HATS Toolkit exists in the
WebFacing perspective.
Starting HATS functions
HATS Toolkit provides several ways to start each HATS function. You can:
v Right-click a HATS resource in the HATS Projects view and select the function
you want from the pop-up menu.
v Click a HATS icon on the toolbar. These icons are described below.
v Click the HATS item on the menu bar and select from the list of available menu
items.
v Click a link on the Welcome page.
v Click on the HATS Tools item on the menu bar (used when editing a
transformation for a Web application).
v Click on an item from the Palette view (used when editing a transformation for
either Web or rich client applications).
v Use the Properties view to edit components in a transformation.
In many cases, you can start a HATS function in a way that creates linkage
between HATS resources. For example, you can create a screen customization
based on a screen capture by right-clicking on the screen capture and selecting
New HATS > Screen Customization. The screen customization's properties will
default to those of the screen capture.
Using HATS icons
This table shows the HATS icons that are placed on the Rational SDP main toolbar.
Table 1. HATS toolbar icons
Create a HATS project
34
IBM Rational Host Access Transformation Services: Getting Started
Table 1. HATS toolbar icons (continued)
Open the HATS host terminal
Create a HATS connection
Create a HATS host simulation file
Create a HATS macro
Create a HATS screen customization
Create a HATS screen combination
Create a HATS transformation
Create a HATS template
Create a Java file to run custom business logic
Test the selected HATS project in the local test environment using
debug mode
Export a project as a HATS application
Open the HATS Welcome page
Create a linked HATS/WebFacing project (available only if the
WebFacing feature of HATS is installed)
Other icons are available from certain windows, such as the host terminal window.
Those icons will be identified in the sections that describe those windows.
HATS tips
To guide you through the flow of creating a project and its resources, HATS
provides tips when you do certain tasks. You can use the check boxes at the
bottom of the tip window to specify whether you want to see that particular tip in
the future and whether you want to see any tips. You can also control whether tips
are shown by following these steps:
1. From the main menu, click Window > Preferences.
2. In the Preferences window, click HATS in the tree on the left.
3. On the right panel, locate the check box labeled Show HATS tips. Check this
box if you want tips to appear, or clear it if you do not want tips.
4. Click OK at the bottom of the Preferences window.
Note: If you have chosen to disable showing one or more individual tips, but have
not disabled tips completely, you can re-enable showing the individual tips.
To do so, clear the Show HATS tips check box and click Apply, then select
the Show HATS tips check box and click OK.
Chapter 5. Creating a basic HATS project
35
Developing a HATS project
There are different paths you can take when building a HATS application. You
might want to build an application that allows an end-user to navigate the host
screens in an emulator-like fashion, or you might want to build an application that
uses Integration Objects to collect data from the host and present that data on a
Web page. You can even combine host screen navigation in the GUI with host data
collection using Integration Objects in one Web application.
You can see step-by-step examples of HATS screen navigation and HATS
Integration Objects in the HATS Tutorials section of the HATS Information Center
located at http://pic.dhe.ibm.com/infocenter/hatshelp/v90/index.jsp.
The procedures in this section will guide you through the process of developing an
example HATS project. The procedures include information about both HATS Web
and rich client projects. As you follow the procedures, you will perform these
steps:
1. Create a HATS project, with default values, using a wizard in the HATS
Toolkit.
2. Test the project using the local test environment.
3. Make changes to the project. This process is known as customization. Common
customization tasks are described in Chapter 6, “Customizing your HATS
project,” on page 43.
4. Test the project again, and do more customization.
5. Export the project to an application and transfer it to a production
environment. These steps are described in Chapter 7, “Preparing your HATS
project for use as an application,” on page 67.
Creating a HATS project
Begin on the Welcome page. If the Welcome page is not displayed, click the Open
on the main toolbar.
HATS Welcome Page icon
1. Expand the Create your first project section.
2. Click the link to launch the Create a Project wizard.
3. On the HATS Project page:
a. Type the name of the project you are creating.
b. Type a description of the project. This is optional. You can keep notes here
or use it however you want.
c. Leave the Use default location check box selected.
d. In the Deployment section select whether the project is for a Web
application or a rich client application.
Note: If the Web deployment option is disabled, this indicates that no
server runtimes are defined. To define server runtimes, go to
Window > Preferences > Server > Installed Runtimes and add at
least one runtime definition.
v Web
– Select the target server you want to use for your application.
– Supply a name to use for the Enterprise application (.ear file) project
or take the default.
– The Portlet API selection is only active if a WebSphere Portal server is
selected for the target server.
36
IBM Rational Host Access Transformation Services: Getting Started
Note: For information about creating a HATS portlet project, see the
section, Creating HATS portlets, in the HATS User's and
Administrator's Guide.
– Leave the Optimize options for mobile devices check box cleared.
Note: For information about creating a HATS Web project optimized
for mobile devices, see the section, Developing HATS
applications for mobile devices, in the HATS User's and
Administrator's Guide.
– Select Use Dojo technology if you want to use Dojo widgets in this
project.
Note: This box is enabled only for Web projects and not for portlet,
mobile, or rich client projects.
– Leave the Add administration console support check box selected.
v Rich client
– Accept the Plug-in ID and Plug-in version defaults.
– Select the target platform.
e. Click Next.
4. On the Connection Settings page:
a. Type the name of the Telnet or WebFacing server to use to access the host
application. This can be a host name, a domain name (such as
myhost.mycompany.com), an alias, or an IP address.
b. If your host application uses 3270 protocols, select the 3270 or 3270E
connection type depending on the functions required by the application. For
example, printing support requires the 3270E connection type. If your host
application uses 5250 protocols, select the 5250 connection type if it is
accessed through a 5250 Telnet server. Select the 5250W connection type if it
is accessed through a WebFacing server.
c. Select the port, code page and screen size.
d. Click Next.
5. On the Project Theme page, select the overall appearance and behavior you
want for the application. You can select whether you want the application to
appear and behave more like an emulator, more like a modern application, or a
custom setting somewhere in between. Click Next.
6. If you selected the Use Dojo technology setting on the HATS Project page, the
Dojo Project Setup page is displayed at this point. To change the Dojo default
settings, click Change these setup options. To accept the defaults, click Next.
Note: To change Dojo settings after the HATS project is created, from the HATS
Projects view right-click the project and select Properties. On the
properties page select Dojo Toolkit.
7. On the Default Template page, all of the templates provided with HATS are
displayed. Choose one to use as a starting point for your project. Click Finish.
8. A progress bar displays as HATS creates the project.
You have created a simple HATS project. Next, you will test the project using the
local test environment.
Chapter 5. Creating a basic HATS project
37
Testing your project
Testing modes for Web projects
Three different modes can be used for testing your Web projects, Run on Server,
Debug on Server, and Profile on Server.
Run on Server
Use this mode to test HATS Web and portlet projects in a WebSphere
Application Server or WebSphere Portal instance, as appropriate. In this
mode you can modify and test the runtime settings, defined in the
runtime.properties file, that are deployed to the runtime environment. Be
aware that any changes made to the runtime settings while testing in this
mode are retained and become effective when you deploy the HATS
application to a runtime environment. For more information about
changing runtime settings see the HATS User's and Administrator's Guide.
To use this mode, in the HATS Projects view right-click your project and
select Run on Server.
Debug on Server
Same as Run on Server and in addition enables you to:
v Use the display terminal to see host screens as they are navigated while
testing your project.
v See debug messages in the Rational SDP console.
v See changes you make to your project, for example changing the
template or a transformation, without having to restart your application
on the test server.
v Modify and test runtime settings, defined in the runtimedebug.properties file, without modifying the settings, defined in the
runtime.properties file, that are deployed to the runtime environment.
v Step through Java code, such as HATS business logic.
To use this mode, in the HATS Projects view right-click your project and
select Debug on Server.
Profile on Server
Same as Run on Server, and in addition enables you to locate the
operations that require the most time, and identify actions that are
repeated, to eliminate redundancy. You can use this function for
performance analysis, helping you to get a better understanding of your
application.
To use this mode, in the HATS Projects view right-click your project and
select Profile on Server.
Testing your Web project
Begin on the Welcome page. If the Welcome to HATS page is not displayed, click
the Welcome to HATS tab at the top of the editor pane.
1. In the HATS Projects view on the left side of the screen, select the name of the
Web project you just created.
2. On the Welcome page, click Debug On Server.
3. You are given the option to see the display terminal while running the project.
Click Yes to see the host screens in the display terminal as they are navigated
while you test your project.
4. The Server Selection window opens, where you select the server on which to
run your project. Select the server to use. Click Finish to complete the run on
server process.
38
IBM Rational Host Access Transformation Services: Getting Started
Note: The server selection must be compatible with the server you chose when
creating your HATS project.
Rational SDP launches an instance of the selected server to run your project on
your local system. When you test your project, you are using a local copy of the
server that is provided with Rational SDP. This local server is also called the local
test environment.
Note: If after launching it, the local server stays in either Starting or Publishing
state, the CPU utilization spikes to 100%, or your Web project starts but
displays a blank page, then make the following local server configuration
changes to try to remedy these issues:
1. Edit the server by double clicking on the server in the Servers view.
2. In the Server section:
v Select Manually provide connection settings.
v Clear the RMI Connection Type, and select the SOAP Connection
Type.
3.
4.
5.
6.
v Select Terminate server on workbench shutdown.
In the Publishing section:
v Select Never publish automatically.
If the server is running, restart the server for the changes to take effect.
One other tip: Do not use the same EAR name across different
workspaces. If the same EAR file names are used in different
workspaces, 404 errors can occur or the wrong application is presented.
At project creation time, HATS always defaults to an EAR name that is
based on the version of WebSphere Application Server for which you are
creating the project. For example, when the target server is WebSphere
Application Server v8.0, the default EAR name for all HATS projects is
HATS_EAR8. To ensure that different EAR names are used for different
workspaces, specify a unique name in the Enterprise application project
field when creating your HATS project.
If there are still issues, see the technote reference number 1207553, titled
The version 6.x WebSphere Test Environment stays in a Starting. . . state,
for other possible solutions.
When using the Debug on Server function in the HATS Toolkit to test your project,
the Rational SDP console displays messages with the following information:
v The HATS runtime version and build information
v The name of the transformation being applied
v The name of the macro being played
v The name of the Java method being executed for business logic
v The name of the macro being played and the connection on which the macro is
playing during a macro transaction
v The name of the event being processed, such as the start or unmatched screen
events, or your screen customization.
v Indications that settings have changed
The messages are displayed by default. If you want to disable the messages, locate
and double-click the web.xml file in the Web Content/WEB-INF/ path in the
Navigator view to edit it. Select the Source tab, find the
showStudioRuntimeMessages parameter, change the value to false, and save the
web.xml file.
Chapter 5. Creating a basic HATS project
39
A Web browser is launched within Rational SDP which displays a Web page with
which you can test your project. The Web page is divided into two main areas:
v The template, which usually covers the top and left sides of the Web page,
comprising a graphical banner and navigation links. The template area typically
remains the same for all, or most of, the Web pages in your project, giving your
users a consistent appearance.
v The transformation area which presents the transformed host application. The
content of the transformation area is different on each Web page in the project.
To view the application as the user would see it, change the preferences in Rational
SDP to use an external Web browser. To do this, from the Rational SDP menu bar,
select Window > Preferences > General > Web Browser, select Use external Web
browser, and select the external Web browser to use. The Web browser opens with
a URL similar to the following: http://localhost:9080/myapp/. To enable other
users to see the Web page from a different machine, give them a URL containing
the IP address of the machine that is running HATS Toolkit. For example, change
the URL http://localhost:9080/myapp/ to http://
myworkstation.mycompany.com:9080/myapp/.
Note: HATS supports multiple browser instances from the same workstation
accessing the same HATS application. However, these multiple browser
instances must not share the same HTTP session id.
Testing modes for rich client projects
Three different modes can be used for testing your rich client projects, Run, Debug,
and Profile.
Run
Use this mode to test HATS rich client projects in a new Eclipse, Lotus
Notes, or Lotus Expeditor Client instance. In this mode you can modify
and test the runtime settings, defined in the runtime.properties file, that
are deployed to the runtime environment. Be aware that any changes made
to the runtime settings while testing in this mode are retained and become
effective when you deploy the HATS application to a runtime environment.
For more information about changing runtime settings see the HATS User's
and Administrator's Guide.
To use this mode, in the HATS Projects view right-click your project and
select Run.
Debug
Same as Run and in addition enables you to:
v use the display terminal to see host screens as they are navigated while
testing your project
v see debug messages in the Rational SDP console
v see changes you make to your project, for example changing the
template or a transformation, without having to restart your application
v modify and test runtime settings, defined in the runtimedebug.properties file, without modifying the settings, defined in the
runtime.properties file, that are deployed to the runtime environment
v step through Java code, such as HATS business logic
To use this mode, in the HATS Projects view right-click your project and
select Debug.
Profile
Same as Run, and in addition enables you to locate the operations that
require the most time, and identify actions that are repeated, to eliminate
40
IBM Rational Host Access Transformation Services: Getting Started
redundancy. You can use this function for performance analysis, helping
you to get a better understanding of your application.
To use this mode, in the HATS Projects view right-click your project and
select Profile.
Testing your rich client project
Begin on the Welcome page. If the Welcome to HATS page is not displayed, click
the Welcome to HATS tab at the top of the editor pane.
1. In the HATS Projects view on the left side of the screen, select the name of the
rich client project you just created.
2. On the Welcome page, click Debug.
3. You are given the option to see the display terminal while running the project.
Click Yes to see the host screens as they are navigated while you test your
project.
4. The Debug window opens, where you can create, manage, and run
configurations. For HATS projects with a target platform of Eclipse RCP, HATS
provides a default Eclipse Application configuration named hostaccess that you
can use. Click Debug to complete the process.
Rational SDP launches an instance of the Eclipse RCP runtime environment to run
your project on your local system. When you test your project, you are using a
copy of the Eclipse RCP that is embedded in Rational SDP. This environment is
also called the local test environment.
When the runtime environment is launched, the Host Access perspective is
displayed which contains an Applications view on the left. Your HATS application
is listed in this view. To launch the application, right-click and select Open.
When you open your HATS application it displays in the transformation view. In
the transformation view you see the toolbar, template, and transformation areas.
v The toolbar contains buttons for application-level actions as well as buttons for
actions contributed by the toolbar widget.
v The template provides the overall appearance of the application. It typically
remains the same for all, or most of, the pages in your application, giving your
users a consistent appearance.
v The transformation area presents the transformed host application. The content
of the transformation area is different on each page in the application.
For more information about testing HATS rich client applications see the HATS
User's and Administrator's Guide.
While testing your project
When you test a newly created HATS project, you see what your host application
looks like when the default transformation is applied. This transformation is part
of each project and uses default rendering to provide an automatic conversion of
your host application screens into a GUI. Part of what you do with the HATS
Toolkit is to design transformations that improve the conversion of your host
application screens into a meaningful, usable GUI.
If you make changes to your project while you are testing it in debug on server
mode (for Web projects) or debug mode (for rich client projects), you do not
generally need to start a new test environment to view your changes. Instead, click
the Refresh button on the GUI that is already displayed.
Chapter 5. Creating a basic HATS project
41
Some of the changes you make may not appear when you use a local test
environment until you rebuild and refresh the workspace. You can set preferences
in Rational SDP that cause the workspace automatically to be rebuilt and refreshed
when you make changes. To do this, from the Rational SDP menu bar select
Window > Preferences > General > Workspace and select the Build automatically
and Refresh automatically check boxes. This will enable the changes you make to
appear immediately when you use the local test environment.
After testing your initial project, you may then want to customize it. For example,
you may want to put your own company name into the template and define
widgets (fields, input areas, and other GUI controls) in the transformation area. As
you develop your HATS project, you can use the test environment to test it and to
see how it will look to a user. Here is a sequence of steps you may typically
follow:
1. Create a HATS project.
2. Test it.
3. Make changes based on what you see in the test environment.
4. Refresh the test environment.
5. Repeat until you are satisfied.
For more information about how to customize HATS projects, see Chapter 6,
“Customizing your HATS project,” on page 43.
42
IBM Rational Host Access Transformation Services: Getting Started
Chapter 6. Customizing your HATS project
After following the steps in Chapter 5, “Creating a basic HATS project,” on page
31, you have a HATS project that looks a lot like the original host application. Now
it's time to customize the project. By performing customization, you can:
v Give the GUI an appearance that appeals to your users and is compatible with
your company's image. For example, you can add your company name and logo
and create a navigation area. See “Updating your project's template” on page 47.
v Display data from the host screens in a way that is tailored to the users of your
particular application. See “Working with transformations” on page 53.
v Convert text strings from the host to different strings in the GUI. For example,
field labels or prompts can be converted, if necessary, to be more understandable
to the user. See “Replacing text strings from the host screen” on page 58.
There are other, advanced customization tasks you can do as well. They are
summarized in “Performing other customization tasks” on page 58 and described
more fully in the HATS User's and Administrator's Guide, the HATS Web Application
Programmer's Guide, and the HATS Rich Client Platform Programmer's Guide.
Understanding how a HATS application works
To understand the purpose of the customization techniques described in this
chapter, and how they work together, you must first understand how a HATS
application processes a host screen to convert it to a GUI. When a user accesses a
HATS application, a request is sent to the HATS application, running on a
WebSphere Application Server, a WebSphere Portal, or a rich client platform. The
HATS application forwards the request to the host application and receives a host
screen. The HATS application transforms the host screen, using the customization
you have created in the HATS project, and sends the transformation to the user.
Each time the user interacts with the HATS application, the process is repeated.
The HATS application uses a rules-based approach to determine how to convert
each host screen. HATS applications can contain a list of screen events (screen
customizations and screen combinations), which specify criteria used to match host
screens. Each screen event also lists actions to be taken when a match is found.
Your HATS application compares each host screen to its ordered set of screen
events, and when the first match is found, it performs the specified actions. You do
not have to specify how to convert every single screen from your host application.
If there is no matching screen event for a host screen, HATS performs the actions
defined for the unmatched screen application event, which by default applies the
default transformation. See “Working with screen events” on page 49 for more
information.
Understanding HATS resources
Each HATS project contains a set of different types of resources (artifacts). You can
see the resource types listed under the project name in the HATS Projects view in
the HATS Toolkit. This section defines the key resource types. For definitions of
other HATS resources see the “Glossary” on page 75.
© Copyright IBM Corp. 2002, 2013
43
Connection
A connection is a set of parameters, stored in an .hco file, used by HATS to
connect to a host application. Learn more about connections in the HATS
User's and Administrator's Guide.
Screen event
A screen event is a HATS event that is triggered when a host screen is
recognized by matching specific screen recognition criteria. There are two
types of screen events, screen customizations and screen combinations.
Screen customization
A screen customization is a type of screen event designed to perform a set
of actions when a host screen is recognized. A screen customization
definition, stored in a .evnt file, includes a set of criteria for matching host
screens, and a list of actions to be taken when a host screen matches these
criteria. Screen customizations are described in “Working with screen
events” on page 49.
Screen combination
A screen combination is a type of screen event designed to gather output
data from consecutive, similar host screens, combine it, and display it in a
single output page. The screen combination definition, stored in a .evnt
file, includes a set of screen recognition criteria for both the beginning and
ending screens to be combined, how to navigate from screen to screen, and
the component and widget to use to recognize and render the data
gathered from each screen. Screen combinations are described in “Working
with screen events” on page 49.
Screen capture
A screen capture is an XML representation of a host screen, stored in a .hsc
file, used to create or customize a screen customization, screen
combination, transformation, global rule, or macro. Screen captures are
useful because they enable you to customize an application even when not
connected to the host. They are also useful in creating macros which are
the core of HATS Integration Object and Web services support.
Screen captures of video terminal (VT) host screens can be used to create
or customize a macro using the Visual Macro Editor and as the check-in
screen when configuring pooling. They cannot be used to create screen
customizations, screen combinations, transformations, default rendering, or
global rules.
Macro A macro, stored in a .hma file, automates interactions with the host. It can
send commands to the host, enter data into entry fields, extract data from
the host, and be used to navigate screens on behalf of the user. Macros are
described in the HATS User's and Administrator's Guide.
Template
A template, stored in a .jsp file (for Web projects) or a .java file (for rich
client projects), controls the basic layout and style (such as color and font)
of the application. It also defines the appearance of areas that are common
in most of your GUI, such as a banner and a navigation area. Templates
are described in “Updating your project's template” on page 47.
Transformation
A transformation stored in a .jsp file (for Web projects) or a .java file (for
rich client projects), defines how host components should be extracted and
displayed using widgets in your GUI. Transformations are described in
“Working with transformations” on page 53.
44
IBM Rational Host Access Transformation Services: Getting Started
Using the host terminal screen as you work
As you develop your HATS project, much of your work will involve screens from
your host application. You will use the HATS host terminal to connect to and
interact with your host application and use it for these tasks:
v Creating screen captures to work with offline when you are not connected to the
host
v Creating screen events
v Creating transformations
v Recording and debugging macros
Each of these tasks is described in the following sections.
Note: You also use the host terminal when creating host simulation traces to work
with offline when you are not connected to the host. For more information
see Using host simulation in the HATS User's and Administrator's Guide.
To open a host terminal session, select your project in the HATS Projects view, then
click the Open HATS Host Terminal icon on the main tool bar to open the host
terminal session. You can also open the host terminal from the pop-up menu by
right-clicking any resource in your project, selecting Open Host Terminal, and
then selecting the connection to use. If you leave your host session active, you can
move around in it as you customize your project, creating screen events and
transformations from the active screens. If you prefer, you can navigate to a few
screens in your host application and click the Create Screen Capture icon on the
host terminal tool bar to create screen captures that you can use to create screen
events and transformations.
Table 2 shows the icons that appear on the host terminal screen.
Table 2. HATS host terminal screen icons
Icon
Description
Create a new HATS screen customization, based on the current
screen. The drop-down list shows the screen customizations
whose recognition criteria this screen matches.
Create a new HATS screen combination, based on the current
screen. The drop-down list shows the screen combinations whose
recognition criteria this screen matches.
Connect this host session (disabled when the host session is
connected)
Disconnect this host session (enabled only when the host session
is connected)
Capture this screen
Create a new HATS transformation, based on the current screen
Open a macro. Use the drop-down list to select a macro.
Play a macro. Use the drop-down list to select a macro.
Start recording a macro
Chapter 6. Customizing your HATS project
45
Table 2. HATS host terminal screen icons (continued)
Icon
Description
Stop recording a macro
Save the recorded macro
Step Into (F5) each macro action for debugging purposes
Step Over (F6) the macro screens for debugging purposes
Step Return (F7) in the macro for debugging purposes
Resume (F8) playback of the macro
Define the screen recognition criteria for a macro
Add a prompt action into the current macro (enabled only when
recording a macro)
Add an extract action into the current macro (enabled only when
recording a macro)
Record a loop into the current macro (enabled only when
recording a macro)
Add prompt actions into the current macro for all fields on the
screen (enabled only when recording a macro)
Add extract actions into the current macro for all fields on the
screen (enabled only when recording a macro)
Show or hide the keypad in the host terminal window
Show or hide the textual Operator Information Area (OIA)
Note: When you use the host terminal through the HATS Toolkit, different actions
such as minimizing the terminal window or shifting to a new perspective
can cause the terminal window to lose focus and not regain it. Click the
terminal window at the cursor position to restore the focus to the terminal
window.
Host screen preview
To see what the currently displayed host screen looks like when the HATS
application runs in a production environment, click the Host Screen Preview tab at
the top of the Host Terminal window. The host screen preview first searches the
screen event list in the order specified for your project, and applies the matching
screen event. If there are no matching screen event defined for the current screen,
the project level template and default rendering rules are applied to the screen.
Working with screen captures
Another way to work with host screens is to navigate to several screens on your
host terminal and use the Create Screen Capture icon, shown in the table above, to
capture representations of host screens. After you have captured some host screens,
46
IBM Rational Host Access Transformation Services: Getting Started
you can work with them without being connected to the host computer. You must
create screen captures in order to modify default rendering items or create global
rules.
When you create screen captures, they are stored in the Screen Captures folder
within your project. To work with a screen capture, expand the folder in the HATS
Projects view, then double-click the name of the screen capture to start the screen
capture editor. The editor shows the host screen; click the Preview tab at the
bottom to see how this screen would be transformed by your project.
Click the Host Screen tab at the bottom to return to the host screen. From this tab
you can use the icons on the toolbar at the top of the editor to create a screen
customization, screen combination, or transformation based on this screen capture.
The name of the screen event or transformation defaults to the name of the screen
capture.
Note: Screen captures of video terminal (VT) host screens can be used to create or
customize a macro using the Visual Macro Editor and as the check-in screen
when configuring pooling. They cannot be used to create screen
customizations, screen combinations, transformations, default rendering, or
global rules.
Updating your project's template
Typically, the pages displayed by your HATS application consist of two elements:
v A template containing the static content of the page, such as a company logo,
the name of the company, and navigational links (for Web applications).
v A transformed screen, representing a screen in the host application, on which a
user enters and views data
A template allows you to control the overall appearance of your application. A
template is a JSP file in HATS Web projects or a Java Standard Widgets Toolkit
(SWT) composite class in HATS rich client projects.
Review the examples of transformed screens in “A HATS 3270 example” on page 3
and “A HATS 5250 example” on page 7. In the Web example, the transformed
screen includes three main areas: a graphic title banner, a vertical navigation bar
which contains application keypad buttons, and the host information area. In the
rich client example, the transformed screen includes a horizontal banner, a toolbar
which contains application keypad buttons, and the host information area. The
template provides a consistent appearance for the pages in an application and
enables you to personalize your HATS application. You can use the same template
in more than one application.
Although every screen in your application will normally use the same template,
you can define a screen event so that it applies a transformation that uses a
different template. The new template applies to host screens matching the screen
event. (See “Working with screen events” on page 49 for more information about
screen events.)
You can either modify a template that comes with HATS or create a new template.
Launching the Create a Template wizard allows you to create a blank template, a
template based off one of the templates shipped with HATS, or a Web page (Web
projects only). For your HATS Web projects, you may want to create a template
based off your company's Web site.
Chapter 6. Customizing your HATS project
47
To change the template for your HATS project, follow these steps:
to expand the resources for
1. In the HATS Projects view, click the plus sign
the project.
2. Double-click Project Settings to open the project editor.
3. Click the Template tab at the bottom of the project editor to view the Template
page.
4. Review the templates provided with the HATS Toolkit and select the one that
most closely resembles the way you want your application to look. Save your
changes.
5. Use the editor to modify the template. To open the editor, expand your project
in the HATS Projects view. For Web projects, expand the Web Content and
Templates folders. For rich client projects, expand the Rich Client and
Templates folders. Double-click the name of the template you want to modify.
You can also change the default project template by expanding the Templates
folder. Right-click on the desired template and select Set as Default Template.
For more information about creating and editing templates see the HATS User's
and Administrator's Guide
Editing default rendering
Default rendering is responsible for transforming host screens that have not been
individually customized. Default rendering works to change host components on
the screen to widgets in the GUI. Certain host components are mapped to specific
widgets for conversion in the default transformation. A default list of mapping
items is defined for projects. This list is called a rendering set. You can modify the
rendering set to suit your needs.
The items in the rendering set are processed in the order in which they are listed.
After a rendering item has been applied to a region of the host screen, that region
has been consumed and will not be processed again.
To access the default rendering set, follow these steps:
1. In the HATS Projects view, locate the name of your project. If the list of
resources associated with this project is not already expanded, click the plus
to expand it.
sign
2. Double-click Project Settings.
3. At the bottom of the editor window, click the Rendering tab.
4. In the list of rendering items, click Default Rendering. The list of rendering
sets appears in the upper table on the right. Using the buttons beside the table,
you can add, edit, or remove rendering sets.
5. In the upper table, select the rendering set you want to edit. The mapping
items contained in the rendering set are displayed in the lower table on the
right.
As you can see, there are several items defined in a rendering set. A check box
precedes each item. When the box is selected, the item is active, and the default
transformation uses the item, if HATS finds the component on the screen. If there
is an item that you do not want to use in your project, you can clear the check box
rather than removing the item entirely. Using the buttons beside the table, you can
add, edit, or remove items. The Up and Down buttons allow you to reorder the
rendering items.
48
IBM Rational Host Access Transformation Services: Getting Started
To define additional default rendering items, follow these steps:
1. You create new default rendering items from a screen capture. Begin by
creating a screen capture, as described in “Using the host terminal screen as
you work” on page 45, for each default rendering item you plan to create.
2. Click Add to add a new item to the list.
3. In the New Default Rendering Item window, supply a unique name and
optionally provide a description for the item.
4. In the Select Screen Region dialog:
a. Select a previously captured screen that contains a component for which
you want to assign a widget.
b. In the graphic of the selected screen, draw a rectangle around the region of
the screen that contains the component. For example, click and hold the left
mouse button and move the mouse until the rectangle surrounds the
intended region.
c. Click Next.
5. In the Rendering Options dialog:
a. Select the component from the list of components. If necessary, click the
icon to change the default settings.
component settings
b. Select the widget from the list that you want to assign as the default widget
for the component. If necessary, click the widget settings
the default settings.
icon to change
c. Click Finish.
For more information about default rendering see the HATS User's and
Administrator's Guide.
Creating global rules
Global rules are used to transform specific input fields based on certain criteria.
They apply to both customized screens and screens rendered using default
rendering. In addition to defining global rules at the project-level, they can also be
defined at the screen-level which gives you more control over when the rules are
applied.
Each global rule item is defined in a transformation fragment, which can be
included in other transformations. You can edit the transformation fragments just
like you edit transformations, using all of the options available with
transformations.
For more information about global rules see the HATS User's and Administrator's
Guide.
Working with screen events
A HATS event is a resource that performs a set of actions based on a certain state
being reached. There are two types of HATS events, application events and screen
events. For more information about application events see the HATS User's and
Administrator's Guide. A screen event is a HATS event that is triggered when a host
screen is recognized by matching specific screen recognition criteria. There are two
types of screen events, screen customizations and screen combinations.
Chapter 6. Customizing your HATS project
49
A screen customization is a HATS screen event designed to perform a set of actions
when a host screen is recognized. Examples of screen customizations include
recognizing a screen and transforming it into a GUI for the user or playing a
macro to skip the screen. The screen customization definition includes a set of
screen recognition criteria and a list of actions to be taken when a host screen
matches the screen recognition criteria. Screen-level global rules and text
replacement settings are also included. Use the Create a Screen Customization
wizard to create a new screen customization.
A screen combination is a HATS screen event designed to gather output data from
consecutive, similar host screens, combine it, and display it in a single output page.
An example of a screen combination includes recognizing a screen that contains
only partial output data and navigating through all subsequent screens to gather
all of the remaining data to display for the user. The screen combination definition
includes a set of screen recognition criteria for both the beginning and ending
screens to be combined, how to navigate from screen to screen, and the component
and widget to use to recognize and render the data gathered from each screen.
Also, it includes a list actions to be performed one or more times, screen-level
global rules and text replacement settings. Use the Create a Screen Combination
wizard to create a new screen combination.
Actions that can be performed in a screen event are listed below. For more details
see the HATS User's and Administrator's Guide.
v Applying a transformation to the host screen
v Calling Java methods to execute business logic
v Extracting a value from the host screen into a global variable
v
v
v
v
Inserting data or the value of a global variable onto a host screen
Setting the value of a global variable
Removing a global variable
Sending a global variable (HATS standard portlet projects only)
v Displaying a specified Web page (URL) or SWT composite RCP-only
v Displaying a specified Web page (URL) Web-only
v Forwarding control to a URL Web-only
v Running a macro
v Running a macro transaction on a different connection.
v Sending a key to the host application
v Disconnecting the default connection immediately
v Waiting a specified period of time
Creating a new screen customization
To create a new screen customization, follow these steps:
1. Select your project in the HATS Projects view and expand its resources.
2. To base the screen customization on an active host terminal, bring up the host
terminal, navigate to the screen you want to use, and click the Create HATS
Screen Customization icon on the host terminal tool bar. To base it on a screen
capture, right-click that screen capture in the tree and select New HATS >
Screen Customization. The screen customization is based on the selected host
terminal screen or screen capture, and the name of the screen customization
defaults to one built from text found on the host terminal screen or from the
name of the screen capture. Either of these methods starts the Create a Screen
Customization wizard.
50
IBM Rational Host Access Transformation Services: Getting Started
3. On the Screen Customization page:
v Accept the selected project.
v Accept the default name, or enter a new name for this screen customization.
Optionally, enter a description.
v Click Next.
4. On the Screen Recognition Criteria page:
v If you invoked this wizard from the host terminal or from a screen capture,
the screen that is displayed defaults to that screen. You can change to a
different screen capture if you want to by selecting it from the drop-down
list. The Use the host terminal screen option is available only if a host
terminal session is active.
v Using your mouse, select an area of the screen to use for the screen
recognition criteria. Or, click the Show Advanced button to use more options
to specify which criteria to use to match host screens. You can use several
criteria to match a screen specifically, or fewer criteria to match a broader
range of screens. Refer to HATS User's and Administrator's Guide for more
information about screen recognition criteria.
v Click Next.
5. On the Actions page:
v Specify the actions to be taken when a host screen matches the selection
criteria. By default a new transformation, based on the same screen, is
created with the same name as the screen customization. You can change the
name of the new transformation, specify that an existing transformation be
used, or clear the Apply a transformation check box if you do not want to
apply any transformation. When you apply a transformation, you must select
a transformation pattern to use. For more information about transformation
patterns, see the HATS User's and Administrator's Guide. Also, when you
apply a transformation, you can specify a different template to be used with
it. If you want to play a macro, select the Play a macro check box. If you
want to add other actions, select the Add advanced actions box.
v Click Finish.
You do not have to define your screen customization completely when you define
it. You can edit it later and modify its screen recognition criteria and actions.
Creating a new screen combination
To create a new screen combination, follow these steps:
1. Select your project in the HATS Projects view and expand its resources.
2. To base the screen combination on an active host terminal, bring up the host
terminal, navigate to the screen you want to use, and click the Create HATS
Screen Combination icon on the host terminal tool bar. To base it on a screen
capture, right-click that screen capture in the tree and select New HATS >
Screen Combination. The screen combination is based on the selected host
terminal screen or screen capture, and the name of the screen combination
defaults to one built from text found on the host terminal screen or from the
name of the screen capture. Either of these methods starts the Create a Screen
Combination wizard.
3. On the Screen Combination page:
v Accept the selected project.
v Accept the default name, or enter a new name for this screen combination.
Optionally, enter a description.
v Click Next.
Chapter 6. Customizing your HATS project
51
4. On the Begin Screen Recognition Criteria page:
v If you invoked this wizard from the host terminal or from a screen capture,
the screen that is displayed defaults to that screen. You can change to a
different screen capture if you want to by selecting it from the drop-down
list. The Use the host terminal screen option is available only if a host
terminal session is active.
v Using your mouse, select an area of the screen to use for the screen
recognition criteria. Or, click the Show Advanced button to use more options
to specify which criteria to use to match host screens. You can use several
criteria to match a screen specifically, or fewer criteria to match a broader
range of screens. Refer to HATS User's and Administrator's Guide for more
information about screen recognition criteria.
v Click Next.
5. On the Screen Region page:
v Using your mouse, select the area of the host containing the data you want
to combine from this and subsequent screens.
v Click Next.
6. On the Rendering Options page:
v Select the component to use to recognize the data you are combining.
v Select the widget to use to render the component.
v Click Next.
7. On the Screen Navigation page:
v Set the commands necessary to navigate from the beginning screen, through
intermediate screens, to the end screen of the screen combination.
v Click Next.
8. On the End Screen Recognition Criteria page:
v Set the criteria for recognizing the end screen of the screen combination.
Ending criteria can be based on iteration count, screen descriptor, or
whichever occurs first.
v If using a screen descriptor, use the Select a screen source section and the
Screen drop-down to display the end screen and set the recognition criteria.
v Click Next.
9. On the Action page:
v Specify the transformation and pattern to use to display the results of the
screen combination. By default a new transformation, based on the same
screen, is created with the same name as the screen combination. You can
change the name of the new transformation or specify that an existing
transformation be used. For more information about transformation patterns,
see the HATS User's and Administrator's Guide
v Click Finish.
You do not have to define your screen combination completely when you define it.
You can edit it later and modify its screen recognition criteria and actions.
Ordering and enabling your screen events
Your HATS application checks each incoming host screen against an ordered list of
screen events. It is essential to have the screen events for your project listed in the
correct order. For example, you might have one screen event that recognizes a few
specific screens, and a second one that recognizes a more general set of screens. If
the second one is listed before the first, it might be applied to one of the screens to
which you wanted to apply the first, more specific screen event.
52
IBM Rational Host Access Transformation Services: Getting Started
You can reorder your screen events, or review the order in which they are checked,
in the Project Settings editor. After you have created your project's screen events,
double-click Project Settings in the HATS Projects view. In the editor, click the
Events tab. Review the list of screen events and use the Up and Down buttons if
you want to change the order. The screen event that you want checked first should
be at the top of the list.
You can use the check boxes next to each screen event in the list to enable or
disable the screen event. When the box is selected, the screen event is active. If you
clear the check box, the HATS application will not use that screen event. Disabling
some screen events can be useful during testing and debugging, and will improve
performance if you have a lot of screen events that you do not use.
Note: You can also specify a prioritized list of Next Screens within a screen event
to improve performance. For more information see the HATS User's and
Administrator's Guide.
Working with transformations
A transformation defines the way in which a host screen is converted into a GUI
page. The transformation specifies how to treat each part of the host screen.
Understanding host components and widgets
In host applications, data can be presented in many different ways, such as menus,
tables, and command prompts. These are known as host components. Your HATS
application converts them into graphical elements, or widgets, for displaying data
on a GUI.
HATS comes with a default set of host components, representing the most
frequently used methods of presenting data, as well as a set of widgets associated
with each one. These host components and widgets are listed in Table 3. As you
develop your HATS application, you select a region on the host screen, select a
host component (which is responsible for finding specific contents in that region,
and select a widget (which is responsible for rendering the output of the host
component.
For example, if a host application has a menu in which the user is required to
select one of the several choices, you can design your HATS application to display
the menu on a GUI as a drop-down list. Alternatively, you can have the menu
appear as a list of radio buttons, from which the user makes a choice, or as a list of
links or buttons. You can even develop a custom component or widget.
Table 3. HATS host components and their corresponding widgets
Host component
Widget
Command line
Combo RCP-only
Drop-down (data entry)
List
Popup
Radio button (data entry)
Text input
Combo box (Dojo) Web-only
Filtering select (Dojo) Web-only
Text box (Dojo) Web-only
Field
Field
Chapter 6. Customizing your HATS project
53
Table 3. HATS host components and their corresponding widgets (continued)
54
Host component
Widget
Function key
Button
Button table
Drop-down (selection)
Link
Radio button (selection)
Toolbar RCP-only
HTML DDS keyword
Label
Input field
Calendar Web-only
Check box
Combo RCP-only
Drop-down (data entry)
List
Popup
Radio button (data entry)
Text input
Combo box (Dojo) Web-only
Date text box (Dojo) Web-only
Filtering select (Dojo) Web-only
Text box (Dojo) Web-only
Validation text box (Dojo) Web-only
Input field with hints
Combo RCP-only
Drop-down (data entry)
List
Popup
Radio button (data entry)
Combo box (Dojo) Web-only
Filtering select (Dojo) Web-only
Item selection
Check box
Combo RCP-only
Drop-down (data entry)
Link (item selection)
List
Popup
Radio button (item selection)
Text input
Combo box (Dojo) Web-only
Filtering select (Dojo) Web-only
Light pen (attention)
Button
Link
Radio button (selection)
Light pen (selection)
Check box
Scrollbar field (ENPTUI)
Scrollbar (ENPTUI)
Selection field (ENPTUI)
Button
Check box
Link
Radio button (selection)
IBM Rational Host Access Transformation Services: Getting Started
Table 3. HATS host components and their corresponding widgets (continued)
Host component
Widget
Selection list
Button
Button table
Drop-down (selection)
Link
Radio button (selection)
Toolbar RCP-only
Combo box (Dojo) Web-only
Filtering select (Dojo) Web-only
Subfile
Subfile (check box)
Subfile (drop-down)
Subfile (popup)
Table
Graph (horizontal bar)
Graph (line)
Graph (vertical bar)
Table
Enhanced grid (Dojo) Web-only
Table (field)
Graph (horizontal bar)
Graph (line)
Graph (vertical bar)
Table
Enhanced grid (Dojo) Web-only
Table (visual)
Graph (horizontal bar)
Graph (line)
Graph (vertical bar)
Table
Enhanced grid (Dojo) Web-only
Text
Label
URL
Link
How HATS uses transformations
A HATS transformation is a powerful tool, containing all the information needed
to convert components from host screens into widgets on GUI pages. A
transformation can be used when it is associated with a screen event. The screen
event, described in “Working with screen events” on page 49, includes a list of
actions to be taken when a host screen matches its screen recognition criteria.
Applying a transformation to the host screen is one of the actions that can be
taken.
The easiest way to associate a transformation with a screen event is to create the
transformation at the same time that you create the screen event.
Creating a new transformation
There are many ways to create a new transformation. When you create a screen
event and apply a transformation as one of the actions, HATS will by default
create a transformation with the same name, based on the same host screen, and
associate it with the screen event. Because the transformation is named and
associated with a host screen, it is created without the use of a wizard.
You can also create a transformation in other ways:
v To create a new transformation based on a screen capture, right-click that screen
capture in the HATS Projects view and select New HATS > Transformation. Or
Chapter 6. Customizing your HATS project
55
double-click that screen capture in the tree to start the screen capture editor, and
click the Create HATS Transformation icon.
v To create a new transformation based on an active host terminal, bring up the
host terminal and click the Create HATS Transformation icon.
Either of these methods starts the Create a Transformation wizard. If you create a
transformation directly from a screen capture or from a host terminal, you will
have to associate it with a screen event later by editing the screen event and
adding the transformation as an action. This process is described in HATS User's
and Administrator's Guide.
The Create a Transformation wizard asks you to select the target project, supply a
name for the transformation, supply a package (for rich client projects), and
indicate on which screen the transformation is based. The wizard creates the
transformation and opens it in the transformation editor so that you can add host
components and widgets.
Editing a transformation
While editing a transformation in a HATS Web project, you can use the HATS
Components drawer in the Palette view of the Page Designer to drag new
components onto the page. You can use the Properties view to modify the settings
for the current components. For more information about editing transformations in
HATS Web projects, see Editing transformations for Web projects in the HATS
User's and Administrator's Guide.
For HATS Web projects, in addition to using the Palette view to edit your
transformation, you can use icons on the main toolbar and items from the HATS
Tools menu on the menu bar. The following table lists the icons available on the
main toolbar.
Table 4. HATS transformation editor main toolbar icons
Icon
Description
Insert a host component into the transformation.
Edit a host component
Transform a host component for Dojo editing
Insert the default rendering of a screen or partial screen into the
transformation
Edit the default rendering
In addition to the icons on the main toolbar, for HATS Web projects you can use
functions from the HATS Tools menu on the menu bar to insert items into a
transformation while editing the transformation. These functions are listed in the
table below.
56
Insert Function
Description
Insert Tabbed Folder
Inserts a folder with tabs. This function is
deprecated in HATS V9.0. For alternatives
see Insert Tabbed Folder in the HATS User's
and Administrator's Guide.
IBM Rational Host Access Transformation Services: Getting Started
Insert Function
Description
Insert Macro Key
Adds a button, link, or drop-down list to
enable the end user to execute a macro.
Insert Global Variable
Inserts a global variable as text, or as a
prompt for a global variable with input
fields.
Insert Operator Information Area
Inserts the Operator Information Area which
shows terminal attributes on the screen.
Insert Host Keypad > Default Keypad
Adds the default host keypad.
Insert Host Keypad > Custom Keypad
Adds a customized host keypad containing
only the keys that you select.
Insert Host Keypad > Individual Key
Adds individual host keys that you select.
Insert Application Keypad > Default Keypad Adds the default application keypad.
Insert Application Keypad > Custom
Keypad
Adds a customized application keypad to
the template on your Web page, containing
the keys that you select.
Insert Application Keypad > Individual Key
Adds individual application keys that you
select to the template on your Web page.
Insert All Host Components
Inserts all possible host components found
on a selected screen capture.
Insert Stored Screen
Inserts a screen that you have stored when
combining multiple host screens.
Insert Integration Object Properties > Input
Inserts inputs from a specified Integration
Object JSP page.
Insert Integration Object Properties > Output Inserts outputs from a specified Integration
Object JSP page.
Insert Forward to HATS Application
Adds a button that forwards JSP control
information to the HATS application started
by the user.
For HATS rich client projects, assuming the Java visual editor feature is installed
with Rational SDP, you can use the Visual Editor to edit your transformations.
With the Visual Editor, the following items in the HATS drawer of the Palette view
can be used. For more information about editing transformations in HATS rich
client projects, see Editing transformations for rich client projects in the HATS
User's and Administrator's Guide.
Item
Description
Component
Launches the Insert Host Component wizard
to insert rendering for a specific component
Default Rendering
Launches the Insert Default Rendering
wizard to insert a default rendering
composite
Macro Key
Launches the Insert Macro Key wizard to
insert a button or link that will run a macro
when clicked
Global Variable
Launches the Insert Global Variable wizard
to display or prompt for the value of a
global variable
Chapter 6. Customizing your HATS project
57
Item
Description
Host Key
Launches the Insert Host Key wizard to
insert a button or link that will send a host
key when clicked
Application Key
Launches the Insert Application Key wizard
to insert a button or link for an application
key function
The use of these functions in the transformation editor is described in the HATS
User's and Administrator's Guide.
Performing other customization tasks
You can also do the following kinds of customization on your HATS project.
Auto advance
The auto advance function provides the ability to have focus advance
automatically to the next input field in the GUI when a user completely fills an
input field. With this feature enabled, GUI focus behaves more like how cursor
movement behaves in a typical terminal emulator; after a user has completely
filled in a field on the host screen, the cursor automatically moves to the beginning
of the next field. To enable this feature on every page of your HATS application, in
the Project Settings editor, on the Other tab, select Client Settings and select the
Enable automatic field advance check box.
For Web applications, you can selectively disable this function for an individual
transformation by adding the following lines just after the </HATS:Form> tag in
the transformation file. To selectively enable the function specify true instead of
false.
<script>
autoAdvance = false;
</script>
For rich client applications, you can selectively disable this function for an
individual transformation by overriding the needsAutoAdvanceSupport method on
the individual transformation as shown below. To selectively enable the function
return true instead of false.
public boolean needsAutoAdvanceSupport(boolean preferredValue) {
return false;
}
For more information about the auto advance function, see the HATS User's and
Administrator's Guide.
Displaying function keys (PF keys)
Many host screens include a list of function keys (PF keys) and their assignments.
You can choose to display these keys graphically in your HATS application. For
more information about displaying function keys, see the description of host
keypad in the HATS User's and Administrator's Guide.
Replacing text strings from the host screen
Your HATS application can replace text strings on host screens with different
output on GUI pages. These text strings must be protected text strings, that is,
58
IBM Rational Host Access Transformation Services: Getting Started
strings that are used only on the screen and never passed to the host application as
input. For example, you can replace the text string used as a field label or prompt.
You can replace text with different text, HTML coding Web-only, or images. Java
regular expression support can be use as part of the text replacement algorithm.
Text strings can even be replaced with a button or link that sends a host key.
You can define text replacement in various ways within a project:
v In the project settings, which replaces the specified text on any screen within the
project
v In a rendering item in a default rendering set
v In a screen event, which replaces the specified text only on screens that match
the screen recognition criteria for that screen event
v In the insert host component wizard, which replaces the specified text only in
the inserted component
If you define text replacement for the same text in both the project settings and in
a screen event with different replacement output, the screen event definition takes
precedence. If you define text replacement for the same text in both the screen
event and component tag level, the component tag level text replacement takes
precedence.
Text replacement using another text string attempts to maintain the original screen
layout. If the replacement text is longer than the text to be replaced, the
replacement text is truncated to fit into the original field size. However, if there is
available white space between the text replacement field and the next host
component, the replacement string uses that white space for the next characters of
your replacement string.
Text replacement with either HTML strings Web-only or images does not
preserve the original screen layout, because the replacement output might not fit
into the original field size. This might cause undesirable formatting results in the
GUI.
Note: The field widget has an option to render the output on a character by
character basis. If you use the field widget, with this option set, to render
the section of the host screen that is replaced with an image, undesirable
formatting will occur.
When replacing text with any chosen replacement, be sure to test your text
replacements carefully to be sure that they do not give unexpected results.
For more information about text replacement see the HATS User's and
Administrator's Guide.
Using macros
You can record a macro to create a set of steps to be taken automatically, such as
providing information for entry fields or selecting menu options. For example, to
access a host application, a user needs to log on to the system with a user ID and
password. Logging on to the system is a good candidate for a macro, because your
project can traverse the logon screens for the user of your application. Also, using
the Visual Macro Editor you can edit the macro to add a conditional path to take if
the user ID or password have expired.
To record a simple logon macro, follow these steps:
Chapter 6. Customizing your HATS project
59
1. Highlight a project in the HATS Projects view, and click the Open HATS Host
).
Terminal icon (
2. Start from the host terminal screen displaying the logon screen, and click the
3.
4.
5.
6.
).
Record Macro icon (
On the Record Macro panel, select the target project, give the macro a name,
such as mylogon, and optionally, add a description. Click Finish.
On the Define the starting screen of the macro panel, you can name the
screen or accept the default name. For this example, name the screen logon.
Select an area of the screen to be used to recognize the screen. Since a logon
screen usually has static text, you can select any text on the screen. Notice that
the Strings check box is selected. You should select the At a specified
position option of the string position criteria, since the selected text should
always be in the same location. The Row and Column fields are filled in with
the coordinates of the screen area you selected. Click Next.
On the Recognition Criteria for Screen panel, the text used to recognize the
screen is already defined for you, using information collected from the
previous screen. Click Finish.
On the host terminal screen displaying the logon screen, enter the user ID and
password required and press the Enter key. To the left of the host screen, the
progression of the macro displays in the Macro Navigator pane.
7. There might be other screens that always appear during logging on to a host
that are not necessary for the end user to see. Take any action that you would
normally take on these screens when logging on, until you navigate to a
screen from which you can access the host application for your project. This
screen might have some explicit text on it that indicates that an application
can be accessed, such as Sign-on complete or Main Menu.
).
8. Click the Stop Macro icon (
9. On the Define the exit screen of the macro panel, give the exit screen a name,
such as finalscreen. This time, you are defining recognition criteria for the
last screen in the macro. Most likely, this is the screen that has the Sign-on
complete or Main Menu text on it. You can select this text to be used to
recognize the exit screen for the macro. If the text you select will always be
located at the same position on the screen, select the At a specified position
option of the string position criteria. Otherwise, select the Anywhere on the
screen option. Click Next.
10. On the Recognition Criteria for Screen panel, the text used to recognize the
screen is already defined for you, using information collected from the
previous screen. Click Finish.
11. You now have recorded a macro that logs a user on to the system. To add this
).
macro to your project, click the Save Macro icon (
12. Now you can close or minimize the host terminal screen, and you can see the
macro named mylogon under the Macros folder of your project in the HATS
Projects view.
You can run the mylogon macro as an action in a screen customization to log a
user on to the host system.
For more information about recording and using macros, refer to the HATS User's
and Administrator's Guide and the HATS Advanced Macro Guide.
60
IBM Rational Host Access Transformation Services: Getting Started
Using Host Publisher artifacts
You can import IBM WebSphere Host Publisher applications, Integration Objects,
and macros into your HATS project using options from the File > Import > HATS
menu. You can also create Web pages directly from imported Integration Objects.
For more information about importing and using Host Publisher artifacts, refer to
the HATS User's and Administrator's Guide. For information about programming
with or customizing Host Publisher Integration Objects, refer to the HATS Web
Application Programmer's Guide.
Creating background connections
When you create a project, you define a connection to the host to handle all
transformations. You can define background connections to different hosts to run
Integration Objects and macros. Secure Sockets Layer (SSL), Web Express Logon
(WEL), pooling, and user lists are supported on these connections. For information
about defining connections, refer to the HATS User's and Administrator's Guide.
Defining global variables
You can define global variables to hold data from, for example, an area of the
screen, and make that data available to business logic, templates, transformations,
and macro prompts. For information about global variables, refer to the HATS
User's and Administrator's Guide.
Applying business logic
You can specify a Java method to be called as one of the actions in a screen event,
to perform business logic. To add business logic to your HATS project, in the
HATS Projects view, right-click on your project and select New HATS > Business
Logic. A wizard prompts you for a target project, a class name and a package
name and then a stub class is created in the Source directory for the project. For
more information about adding business logic to your HATS project, refer to the
HATS Web Application Programmer's Guide or the HATS Rich Client Platform
Programmer's Guide, as appropriate.
Using keyboard support
In addition to representing host-application buttons as part of the screen
presentation, you can enable your users to interact with your application by using
the keyboard. Refer to the HATS User's and Administrator's Guide for more
information.
Creating Integration Objects and EJB projects
You can create Integration Objects from the macros in HATS Web projects and
HATS EJB projects. Refer to the HATS Web Application Programmer's Guide for more
information on Integration Objects.
HATS EJB projects have no folders for Screen Customizations, Screen
Combinations, Screen Captures, or Web Content. EJB projects contain only
connections, macros, and Integration Objects. HATS EJB project support is
deprecated in HATS V9.0. While support continues for now, IBM reserves the right
to remove this capability in a subsequent release of the product. Refer to the HATS
Web Application Programmer's Guide for more information on creating and
alternatives to using EJB projects.
Integration Objects can be used in Web Services and portlets. Refer to the HATS
Web Application Programmer's Guide for more information.
Chapter 6. Customizing your HATS project
61
You can also create Model 1, Struts, or JSF Web pages to run your Integration
Objects. Refer to the HATS User's and Administrator's Guide for more information.
Specifying a workstation ID
In the editor for a 5250 connection you can specify Workstation ID properties.
Workstation ID settings include None, Prompt user, Use a specified value, and
Use an HTTP session variable Web-only.
For more information about workstation IDs, refer to the HATS User's and
Administrator's Guide.
Using print support
You can add support to your HATS project for local viewing and printing of files
from the host application. Refer to the HATS User's and Administrator's Guide for
more information.
For a HATS 5250 print support step-by-step example, go to the HATS Information
Center located at http://pic.dhe.ibm.com/infocenter/hatshelp/v90/index.jsp.
Subfile support
HATS can recognize a subfile on a 5250 host screen using the subfile component,
and render it in the GUI using the subfile (check box), subfile (drop-down) or
subfile (popup) widgets. See a sample host screen containing a subfile Figure 15 on
page 63 and the same screen as rendered by the subfile (drop-down) widget in
Figure 16 on page 63.
For more information about subfile support, refer to the HATS User's and
Administrator's Guide.
62
IBM Rational Host Access Transformation Services: Getting Started
Work with Active Jobs
CPU %:
.0
Elapsed time:
ELCRTP68
10/25/06 15:57:41
Active jobs: 356
00:00:00
Type options, press Enter.
2=Change 3=Hold 4=End 5=Work with 6=Release 7=Display message
8=Work with spooled files 13=Disconnect...
Opt Subsystem/Job
___
QBATCH
___
QCMN
___
QCTL
___
QSYSSCD
___
QHTTPSVR
___
ADMIN
___
ADMIN
___
ADMIN
___
ADMIN
Current
User
Type
SBS
QSYS
SBS
QSYS
SBS
QSYS
BCH
QPGMR
SBS
QSYS
QTMHHTTP BCH
QTMHHTTTP BCI
QTMHHTTP BCI
SHEEHAND BDI
CPU%
.0
.0
.0
.0
.0
.0
.0
.0
.0
Function
PGM-QEZSCNEP
PGM-QZHBMAIN
PGM-OZSRLOG
PGM-QZSRHTTP
PGM-QYUNLANG
Status
DEQW
DEQW
DEQW
EVTW
DEQW
SIGW
SIGW
SIGW
TIMW
More...
Parameters or command
===>
F3=Exit
F5=Refresh
F11=Display elapsed data
F7=Find
F10=Restart statistics
F12=Cancel F23=More options F24=More keys
Figure 15. Subfile host screen
My Company
Innovative technologies designed for the future
Links
Home
My Company Home Page
My Company Map
My Company Employees
Jobs at My Company
My Company Articles
Support
About My Company
Stock Quote
Work with Active Jobs
CPU %: .0
Elapsed time:
Type options, press Enter.
Opt
Subsystem/Job
QBATCH
QCMN
QCTL
QSYSSCD
QHTTPSVR
ADMIN
ADMIN
ADMIN
ADMIN
Reset
Default
Refresh
Disconnect
Turn Keyboard Off
00:00:00
10/25/06
Active jobs: 356
Current
User
Type
CPU%
SYS
QSYS
QSYS
QPGMR
QSYS
QTMHHTTP
QTMHHTTP
QTMHHTTP
SHEEHAND
SBS
SBS
SBS
BCH
SBS
BCH
BCI
BCI
BCI
.0
.0
.0
.0
.0
.0
.0
.0
.0
Function
ELCRTP68
15:57:41
Status
DEQW
DEQW
DEQW
PGM-QEZSCNEP EVTW
DEQW
PGM-QZHBMAIN SIGW
SIGW
PGM-QZSRLOG
PGM-QZSRHTTP SIGW
PGM-QYUNLANG TIMW
More...
Parameters or command
F3=Exit
F5=Refresh
F11=Display elapsed data
Contact Us
F7=Find
F12=Cancel
Human Resources
F10=Restart statistics
F23=More options
F24=More keys
Employee Information
Figure 16. Subfile with default rendering
Using Extended Field Attributes
Fields on 5250 host screens can be marked with specific "check" keywords. Check
keywords allow the host application to tell the emulator how certain fields need to
react to specific key presses (this key is normally "field exit"). For example, when a
field is marked as "auto enter", once a user supplies X number of characters into
the field (X being the size of the field), the emulator automatically submits the
page back to the host application for processing.
The following 5250 check keywords are supported:
1. Validity checking:
Chapter 6. Customizing your HATS project
63
v AB (allow blanks)
v ME (mandatory entry), generated text boxes marked with "entryRequired"
attribute
v MF (mandatory fill), generated text boxes marked with "fillRequired"
attribute
v MOD10 (IBM modulus 10 check), generated text boxes marked with "mod10"
attribute
v MOD11 (IBM modulus 11 check), generated text boxes marked with "mod11"
attribute.
2. Keyboard control:
v RB (right fill with blanks), text in field is right-filled with blanks when user
leaves the field
v RZ (right fill with zeros), text in field is right-filled with zeros when user
leaves the field
v ER (auto enter on field completion), form is automatically submitted (back to
the HATS server) when the field is filled
v LC (allow lowercase characters), lowercase characters are not converted to
upper case (if enabled)
v FE (field exit required), user is required to press a field exit key to leave the
field.
A field on a host screen can also be marked to allow only a certain type of
input. For example, the user name and password field on a typical IBM i Sign
On screen allows only uppercase letters and digits. With this information
available, HATS can generate text boxes which, on the client, restrict key
presses based on the field type. For example, if a host screen field is marked as
"numeric only", only numerals (and other numeric support characters) will be
allowed to be entered into the generated text box. This will reduce the chance
of the screen becoming locked or being returned to the user with a message
they may have never seen before (since most emulators restrict input).
3. Input restrictions:
v X (alphabetic only, lowercase are converted into uppercase)
v A (alphanumeric shift, everything permitted)
v S (signed numeric, requires field exit)
v N (numeric shift; 0-9, user must press field+,-,exit)
v Y (numeric only, 0-9, plus, minus, period, comma, space)
v D (digits only, 0-9, field minus not allowed).
By default, support for all of these field attributes is enabled. To disable client-side
numeric value formatting, follow these steps to edit your project settings file:
1. In the HATS Projects view, open the project you want to update.
2. Double-click Project Settings.
3. Click the Project Settings Source tab.
4. For Web applications, in the following class names, add or change the
enableCheckAttributes setting to:
<setting name="enableCheckAttributes" value="false"/>
com.ibm.hats.transform.widgets.FieldWidget
com.ibm.hats.transform.widgets.CalendarWidget
com.ibm.hats.transform.widgets.InputWidget
com.ibm.hats.transform.widgets.PopupWidget
com.ibm.hats.transform.widgets.TableWidget
64
IBM Rational Host Access Transformation Services: Getting Started
5. For rich client applications, in the following class names, add or change the
enableCheckAttributes setting to:
<setting name="enableCheckAttributes" value="false"/>
com.ibm.hats.rcp.transform.widgets.SwtComboWidget
com.ibm.hats.rcp.transform.widgets.SwtFieldWidget
com.ibm.hats.rcp.transform.widgets.SwtInputWidget
com.ibm.hats.rcp.transform.widgets.SwtPopupWidget
com.ibm.hats.rcp.transform.widgets.SwtTableWidget
By disabling this setting, the user loses support for the following attribute
checking:
v AB (allow blanks)
v RB (right fill with blanks)
v RZ (right fill with zeros)
v ER (auto enter on field completion)
v LC (allow lowercase characters)
You can also add these settings manually to any component in your
transformations.
For Web applications add the following settings to the component:
<HATS:Component ... widgetSettings="enableCheckAttributes:false|
enableInputRestrictions:false"/>
For rich client applications add the following settings to the component:
ComponentRendering rendering1 = new ComponentRendering(this, 0);
...
rendering1.setWidgetSettings(new StringableProperties("enableCheckAttributes:false|
enableInputRestrictions:false"));
Note: To use the "auto enter" feature, the auto advance feature must be enabled;
see below for more information.
For more information about extended field attributes, refer to the HATS User's and
Administrator's Guide, the HATS Web Application Programmer's Guide, and the HATS
Rich Client Platform Programmer's Guide.
Enabling Enhanced Non-Programmable Terminal User
Interface (ENPTUI)
ENPTUI enables an enhanced user interface on non-programmable terminals (NPT)
and programmable work stations (PWS) over the 5250 full-screen menu-driven
interface, taking advantage of 5250 display data stream extensions. These
extensions can be also accessed via the DDS programming interface. Graphical
DDS keywords specify the GUI controls to be displayed.
HATS recognizes these 5250 display data stream extensions when used, and
renders them into appropriate GUI controls. The following subset of graphical DDS
keywords are supported:
v
v
v
v
v
PSHBUTTON - Push Buttons
MLTCHCFLD - Check Boxes
SNGCHCFLD - Radio Buttons
SFLSNGCHC - Single-selection List box
SFLMLTCHC - Multiple-selection List box
Chapter 6. Customizing your HATS project
65
v WINDOW - Popup Window
v MNUBAR - Menu Bar
v PULLDOWN - Pull-down Menus
For more information about ENPTUI support, refer to the HATS User's and
Administrator's Guide.
5250 HTML DDS keyword support Web-only
DDS programmers can use the HTML keyword to imbed raw HTML data into the
5250 data stream. HATS will enable data that is sent from a host application in the
HTML DDS keyword to be rendered in the browser.
For more information about HTML DDS support, refer to the HATS User's and
Administrator's Guide.
66
IBM Rational Host Access Transformation Services: Getting Started
Chapter 7. Preparing your HATS project for use as an
application
After you develop and test your HATS project, you can deploy it as an application
in a runtime environment. The deployment tasks differ depending on whether you
are deploying a HATS Web application or a HATS rich client application. Both are
discussed below.
Deploying HATS Web applications
The terms HATS Web application, WebSphere application, and Java EE application can
be used interchangeably to refer to a Web application created from a HATS project.
It is a HATS Web application because it was developed in the HATS Toolkit. It is a
WebSphere application because it will be installed and run on WebSphere
Application Server. It is a Java EE application because it conforms to the Java EE
standards.
Note: HATS portlets are special cases of HATS Web applications. For more
information about developing and deploying HATS portlets see the chapter,
WebSphere Portal and HATS, in the HATS User's and Administrator's Guide.
To deploy your HATS Web application in a runtime environment you must:
v Export your project as an application.
v Install your application in a runtime environment.
The following sections summarize each of these tasks. For details about how to
perform these tasks, see the section, Deploying HATS Web applications, in the
HATS User's and Administrator's Guide.
Exporting your project as an application
To deploy your HATS Web application to a runtime environment, you must first
package it as a Java EE application. To package your application as a Java EE
application, from the HATS Projects view, right-click your Web project and from
the pop-up menu select Export Project to launch the EAR Export wizard. The
wizard can also be launched by selecting your Web project and clicking the Export
HATS Project
icon on the Rational SDP toolbar.
Installing your application in a runtime environment
After exporting the HATS project as an application and transferring the
application's .ear file to the production system, install it using the WebSphere
administrative console. For more information about installing applications on
WebSphere Application Server refer to the WebSphere Application Server library
and select the link to the information center for your version of WebSphere
Application Server. In the contents under your WebSphere Application Server
product, refer to the chapter about deploying applications.
© Copyright IBM Corp. 2002, 2013
67
Deploying HATS rich client applications
To deploy your HATS rich client application in a runtime environment you must:
v Export your project as an Eclipse feature.
v Export the HATS runtime features.
v Create an update site.
v Install your application in a runtime environment.
The following sections summarize each of these tasks. For details about how to
perform these tasks, see the section, Deploying HATS rich client applications, in
the HATS User's and Administrator's Guide.
Exporting your project as an Eclipse feature
To deploy your HATS rich client application plug-in to a runtime environment,
you must first package it into an Eclipse feature. An Eclipse feature is a
deployment artifact used to package associated plug-ins. To package your plug-in
into an Eclipse feature, from the HATS Projects view, right-click your rich client
project and from the pop-up menu select Export > Export Feature. Assuming your
project is not already part of a feature, a dialog will prompt you to create the
feature now. Click Yes to launch the Create a HATS Feature Project wizard.
Exporting HATS runtime features
In a production environment, a HATS rich client application feature depends on
the HATS runtime features being installed on the client. When you create a HATS
rich client application feature using the Create a HATS Feature Project wizard, it
will automatically include a dependency on the HATS runtime features. This
dependency is what causes the feature install and update process to automatically
pull down the HATS runtime features from the update site when a HATS rich
client application feature is installed or updated.
To export the HATS runtime features, in the HATS Projects view right-click on
your HATS rich client project and from the pop-up menu select Export > Export
HATS Runtime Features. This launches the Export HATS Runtime Features
wizard. The wizard can also be launched from the Rational SDP menu bar by
selecting File > Export > HATS > HATS Runtime Features.
Creating an update site
After exporting both your HATS application feature and the HATS runtime
features, you must create an update site that can be used by the feature install and
update process to deploy your application. To create an update site, from the
Rational SDP menu bar, select File > New > Other. On the Select a wizard panel,
select Plug-in Development > Update Site Project and click Next to launch the
Update Site Project wizard.
Installing your application in a runtime environment
HATS rich client applications can run in Eclipse RCP, Lotus Notes, and Lotus
Expeditor Client environments. The following sections summarize how to install
your HATS rich client application in each of these environments.
Eclipse RCP
To install your HATS rich client application in an Eclipse rich client platform
environment, the client must be configured to access the update site containing the
application. By default, since automatic install and update is disabled, the user or
68
IBM Rational Host Access Transformation Services: Getting Started
administrator must manually install the new features or updates using the
standard Eclipse Software Updates functions. To do this, on the client system, from
the Eclipse main menu select Help > Software Updates.
Lotus Notes
In the Lotus Notes environment, a widget is used to install applications that are
provided as features and plug-ins. The widget can later be published to a Widget
catalog for others to use. For more information about widgets, see the Widgets and
Live Text section in the Lotus Notes Information Center at http://
publib.boulder.ibm.com/infocenter/domhelp/v8r0/index.jsp?topic=/
com.ibm.notes85.help.doc/wid_app_overview_c.html .
For details about how to create a widget to install HATS, see the section, Lotus
Notes, in the HATS User's and Administrator's Guide.
Lotus Expeditor Client
In the Lotus Expeditor Client environment application management and
deployment can be controlled in a number of ways:
v Lotus Expeditor Server, which contains the Device Manager Server component
v WebSphere Portal, which allows for centrally administered, role-based access to
applications
v Eclipse update site, which provides provisioning and updating using a standard
Web server
For more information see the Assembling and Deploying Lotus Expeditor
Application section in the Lotus Expeditor Information Center at
http://publib.boulder.ibm.com/infocenter/ledoc/v6r2/index.jsp.
To install your HATS rich client application in a Lotus Expeditor Client
environment, the client must be configured to access the update site containing the
application. To do this, on the client system, from the Lotus Expeditor Client main
menu select File > Application > Install.
Chapter 7. Preparing your HATS project for use as an application
69
70
IBM Rational Host Access Transformation Services: Getting Started
Notices
This information was developed for products and services offered in the U.S.A.
IBM may not offer the products, services, or features discussed in this document in
other countries. Consult your local IBM representative for information on the
products and services currently available in your area. Any reference to an IBM
product, program, or service is not intended to state or imply that only that IBM
product, program, or service may be used. Any functionally equivalent product,
program, or service that does not infringe any IBM intellectual property right may
be used instead. However, it is the user's responsibility to evaluate and verify the
operation of any non-IBM product, program, or service.
IBM may have patents or pending patent applications covering subject matter
described in this document. The furnishing of this document does not give you
any license to these patents. You can send license inquiries, in writing, to:
IBM Director of Licensing
IBM Corporation
North Castle Drive
Armonk, NY 10504-1785
U.S.A.
For license inquiries regarding double-byte (DBCS) information, contact the IBM
Intellectual Property Department in your country or send inquiries, in writing, to:
Intellectual Property Licensing
Legal and Intellectual Property Law
IBM Japan, Ltd.
19-21, Nihonbashi-Hakozakicho, Chuo-ku
Tokyo 103-8510, Japan
The following paragraph does not apply to the United Kingdom or any other
country where such provisions are inconsistent with local law:
INTERNATIONAL BUSINESS MACHINES CORPORATION PROVIDES THIS
PUBLICATION “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER
EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS
FOR A PARTICULAR PURPOSE. Some states do not allow disclaimer of express or
implied warranties in certain transactions, therefore, this statement may not apply
to you.
This information could include technical inaccuracies or typographical errors.
Changes are periodically made to the information herein; these changes will be
incorporated in new editions of the publication. IBM may make improvements
and/or changes in the product(s) and/or the program(s) described in this
publication at any time without notice.
Any references in this information to non-IBM Web sites are provided for
convenience only and do not in any manner serve as an endorsement of those Web
sites. The materials at those Web sites are not part of the materials for this IBM
product and use of those Web sites is at your own risk.
IBM may use or distribute any of the information you supply in any way it
believes appropriate without incurring any obligation to you.
© Copyright IBM Corp. 2002, 2013
71
Licensees of this program who wish to have information about it for the purpose
of enabling: (i) the exchange of information between independently created
programs and other programs (including this one) and (ii) the mutual use of the
information which has been exchanged, should contact:
Intellectual Property Dept. for Rational Software
IBM Corporation
5 Technology Park Drive
Westford, MA 01886
U.S.A.
Such information may be available, subject to appropriate terms and conditions,
including in some cases, payment of a fee.
The licensed program described in this information and all licensed material
available for it are provided by IBM under terms of the IBM Customer Agreement,
IBM International Program License Agreement, or any equivalent agreement
between us.
Information concerning non-IBM products was obtained from the suppliers of
those products, their published announcements or other publicly available sources.
IBM has not tested those products and cannot confirm the accuracy of
performance, compatibility or any other claims related to non-IBM products.
Questions on the capabilities of non-IBM products should be addressed to the
suppliers of those products.
This information contains examples of data and reports used in daily business
operations. To illustrate them as completely as possible, the examples include the
names of individuals, companies, brands, and products. All of these names are
fictitious and any similarity to the names and addresses used by an actual business
enterprise is entirely coincidental.
COPYRIGHT LICENSE:
This information contains sample application programs in source language, which
illustrates programming techniques on various operating platforms. You may copy,
modify, and distribute these sample programs in any form without payment to
IBM, for the purposes of developing, using, marketing or distributing application
programs conforming to the application programming interface for the operating
platform for which the sample programs are written. These examples have not
been thoroughly tested under all conditions. IBM, therefore, cannot guarantee or
imply reliability, serviceability, or function of these programs. The sample
programs are provided "AS IS", without warranty of any kind. IBM shall not be
liable for any damages arising out of your use of the sample programs.
If you are viewing this information softcopy, the photographs and color
illustrations may not appear.
Programming interface information
This Getting Started guide contains information on intended programming
interfaces that allow the customer to write programs to obtain the services of
HATS.
72
IBM Rational Host Access Transformation Services: Getting Started
Trademarks
IBM, the IBM logo, and ibm.com are trademarks or registered trademarks of
International Business Machines Corp., registered in many jurisdictions worldwide.
Other product and service names might be trademarks of IBM or other companies.
A current list of IBM trademarks is available on the Web at “Copyright and
trademark information” at www.ibm.com/legal/copytrade.shtml.
Microsoft and Windows are trademarks of Microsoft Corporation in the United
States, other countries, or both.
Java and all Java-based trademarks and logos are trademarks or registered
trademarks of Oracle and/or its affiliates.
Notices
73
74
IBM Rational Host Access Transformation Services: Getting Started
Glossary
action. A defined task that an application performs on a managed object as a result of an event, such as a host
screen matching the screen recognition criteria specified for a screen event. A list of actions is part of the definition of
each event.
ADB. See application data buffer.
administrative console. The HATS administrative console is a Web-based utility that provides views and functions
to manage licenses and connections, set log and trace settings, view messages and traces, and perform problem
determination for HATS Web applications.
application. See HATS application.
application data buffer. The format of data that is returned by the WebFacing Server for consumption by the
WebFacing application.
application event. A HATS event that is triggered by state changes in the application's life cycle. Examples of
application events include a user first accessing a HATS application (a Start event), or an application encountering an
unrecognized screen (an Unmatched Screen event).
application keypad. A set of buttons or links representing HATS application-level functions. (Contrast with host
keypad.)
artifact. See resource
background connection. Any connection defined in a HATS application other than the default connection. HATS
does not transform screens from background connections. (Contrast with default connection.)
bidirectional (bidi). Pertaining to scripts such as Arabic and Hebrew that generally run from right to left, except for
numbers, which run from left to right.
BMS map. A screen definition file used with Basic Mapping Support in CICS. A BMS map defines a set of fields
which are to be displayed as a group by a CICS application
business logic. Java code that performs advanced functions, such as interacting with other applications, databases,
or other systems accessible via Java APIs. Business logic is invoked as an action in an application or screen event.
checkin screen. The screen identifying the host screen that should be active for a connection to be considered ready
to be returned to the connection pool. If the application is not on the screen specified by the checkin screen, the
connection will be discarded or recycled in attempt to return the connection to the host screen specified by the
checkin screen. The checkin screen is only meaningful if connection pooling is specified for a connection.
component. A visual element of a host screen, such as a command line, function key, or selection list. HATS
applications transform host components into widgets.
connection. A set of parameters used by HATS, stored in an .hco file, to connect to a host application. (See also
default connection and background connection.)
connection pool. A group of host connections that are maintained in an initialized state, ready to be used without
having to create and initialize them.
credential mapper. The component of Web Express Logon that handles requests for host credentials, which have
been previously authenticated by a network security layer. (See network security layer.)
DDS map. Data Description Specification map. These maps define the layout and behavior of the presentation space
for IBM i terminal applications.
Debug. For rich client projects, the same as Run, and in addition enables you to:
v Use the display terminal to see host screens as they are navigated while testing your project
v See debug messages in the Rational SDP console
© Copyright IBM Corp. 2002, 2013
75
v See changes you make to your project, for example changing the template or a transformation, without having to
restart your application
v Modify and test runtime settings, defined in the runtime-debug.properties file, without modifying the settings,
defined in the runtime.properties file, that are deployed to the runtime environment
v Step through Java code, such as HATS business logic
Debug on Server. For Web projects, the same as Run on Server, and in addition enables you to:
v Use the display terminal to see host screens as they are navigated while testing your project
v See debug messages in the Rational SDP console
v See changes you make to your project, for example changing the template or a transformation, without having to
restart your application on the test server
v Modify and test runtime settings, defined in the runtime-debug.properties file, without modifying the settings,
defined in the runtime.properties file, that are deployed to the runtime environment
v Step through Java code, such as HATS business logic
default connection. The connection on which HATS transforms and presents host application screens to the user.
Also referred to as transformation connection. (Contrast with background connection.)
default rendering. The method used by HATS to render parts of the host screen for which no specific
transformation is specified.
deploy. To make a HATS application ready for use in a runtime environment. For HATS Web applications, this
includes exporting the HATS project as a Java EE application, that is, as an .ear file, and installing it on WebSphere
Application Server. For HATS rich client applications, this includes exporting the HATS project as an Eclipse feature
and installing it on individual client systems, either as a stand-alone Eclipse application or from an update site to an
existing Eclipse runtime environment.
descriptor. See screen recognition criteria.
developer. The person who uses HATS Toolkit to develop applications; also application developer or Web
developer. (Contrast with user.)
Device Runtime Environment (DRE). A package containing other runtime environments, including the J2SE
runtime, which is required to run HATS rich client applications in Lotus Expeditor Client V6.2.0 and earlier. The DRE
installs into the runtime environment for Lotus Expeditor Client.
display terminal. A terminal window that displays host screens you can use while testing and debugging to
observe interactions between a HATS application and a host application at runtime. You can also interact with the
host application using host screens in the terminal window.
Eclipse. An open-source initiative that provides ISVs and other tool developers with a standard platform for
developing plug-compatible application development tools. Eclipse is available for download from
http://www.eclipse.org.
editor. An application that enables a user to modify existing data. In HATS Toolkit, editors are used to customize
resources that have been created by wizards.
Enhanced Non-Programmable Terminal User Interface (ENPTUI). Enables an enhanced interface on
non-programmable terminals (NPT) and programmable work stations (PWS) over the 5250 full-screen menu-driven
interface, taking advantage of 5250 display data stream extensions.
enterprise archive (EAR). A specialized Java archive (JAR) file, defined by the Java EE standard used to deploy Java
EE applications to Java EE application servers. An EAR file contains enterprise beans, a deployment descriptor, and
Web archive (WAR) files for individual Web applications. (Sun)
Enterprise JavaBeans (EJB). A component architecture defined by Oracle for the development and deployment of
object-oriented, distributed, enterprise-level applications. (Oracle)
event. A HATS resource that performs a set of actions based on a certain state being reached. There are two types of
HATS events, application events and screen events.
76
IBM Rational Host Access Transformation Services: Getting Started
export. To collect the resources of a HATS project, along with the necessary executable code, into an application
EAR file (for Web applications) or Eclipse feature (for rich client applications) in preparation for deploying the
application.
Extensible Markup Language (XML). A standard metalanguage for defining markup languages that was derived
from and is a subset of SGML.
GB18030. GB18030 is a new Chinese character encoding standard. GB18030 has 1.6 million valid byte sequences and
encodes characters in sequences of one, two, or four bytes.
global rule. A rule defining how the rendering of specific input fields should be modified based on certain criteria.
Global rules are used in customized screens and screens rendered using default rendering. Global rules can be
defined at the project level or at the screen event level.
global variable. A variable used to contain information for the use of actions. The values of global variables can be
extracted from a host screen or elsewhere, and can be used in templates, transformations, macros, Integration Objects,
or business logic. A global variable can be a single value or an array, and it can be shared with other HATS
applications sharing the same browser session.
HATS. See Host Access Transformation Services.
HATS application. An application that presents a version of a host application to users, either as a Web-enabled
application deployed to WebSphere Application Server, a portlet deployed to a WebSphere Portal, or as an Eclipse
client-side processing plug-in deployed to an Eclipse rich client platform such as Lotus Notes or Lotus Expeditor
Client. A HATS application is created in HATS Toolkit from a HATS project and deployed to the applicable
environment. The deployed application might interact with other host or e-business applications to present combined
information to a user.
HATS EJB project. A project that contains the HATS EJB and Integration Objects that other applications can use to
get host data. A HATS EJB project does not present transformed screens from a host application.
HATS entry servlet. The servlet that is processed when a user starts a HATS Web application in a browser.
HATS project. A collection of HATS resources (also called artifacts), created using HATS Toolkit wizards and
customized using HATS Toolkit editors, which can be exported to a HATS application.
HATS Toolkit. The component of HATS that runs on Rational SDP and enables you to work with HATS projects to
create HATS applications.
Host Access Transformation Services (HATS). An IBM software set of tools which provides Web-based access to
host-based applications and data sources.
host component. See component.
host keypad. A set of buttons or links representing functions typically available from a host keyboard, such as
function keys or the Enter key. (Contrast with application keypad.)
host simulation. Host simulation enables you to record host simulation trace files that can be saved and then used
instead of a live host connection. The recorded trace files can be played back to create screen captures, screen events,
and screen transformations using the host terminal function, create and test macros using the host terminal function,
test HATS applications using the Rational SDP local test environment, and, along with other traces and logs, aid in
troubleshooting a failing scenario in a runtime environment.
host simulation trace. Host simulation trace files record host screens and transactions that can be saved and played
back later instead of using a live host connection. Trace files can be recorded using the host terminal function or
while in the runtime environment.
host terminal. A HATS Toolkit tool. A session tied to a particular HATS connection, which the HATS developer can
use to capture screens, create screen customizations, and record macros.
HTML. Hypertext Markup Language.
HTML widget. See widget
Glossary
77
IBM portlets. Portlets that comply with the IBM Portlet API, which is deprecated in WebSphere Portal. Contrast
with standard portlets.
Integration Object. A Java bean that encapsulates an interaction with a host screen or a series of host screens.
Integration Objects are constructed from macros and can be included in traditional (WSDL-based) Web services,
RESTful Web services, or HATS EJB projects. Integration Objects cannot be used in rich client platform applications.
interoperability. The ability of a computer or program to work with other computers or programs.
interoperability runtime. Common runtime used by a combined HATS/WebFacing application to provide
management of common connection to the backend host. This runtime decides whether data being returned by the
WebFacing server should be handled by the HATS or WebFacing part of the application.
Java Platform, Enterprise Edition (Java EE). An environment for developing and deploying enterprise applications,
defined by Oracle. The Java EE platform consists of a set of services, application programming interfaces (APIs), and
protocols that provide the functionality for developing multitiered, Web-based applications. (Oracle)
JavaServer Faces (JSF). A framework for building Web-based user interfaces in Java. Web developers can build
applications by placing reusable UI components on a page, connecting the components to an application data source,
and wiring client events to server event handlers. (Oracle)
JavaServer Pages (JSP). A server-side scripting technology that enables Java code to be dynamically embedded
within Web pages (HTML files) and run when the page is served, returning dynamic content to a client. (Oracle)
JavaServer Pages Standard Tag Library (JSTL). A standard tag library that provides support for common, structural
tasks, such as: iteration and conditionals, processing XML documents, internationalization, and database access using
the Structured Query Language (SQL). (Oracle)
JSF. See JavaServer Faces.
JSP. See JavaServer Pages.
JSR 168. The Java Portlet Specification addresses the requirements of aggregation, personalization, presentation, and
security for portlets running in a portal environment. Version 1.0 of the Java Portlet Specification, Java Specification
Request 168 (JSR 168), defines standards to enable portlet compatibility between portal servers offered by different
vendors. See JSR 286.
JSR 286. The Java Portlet Specification addresses the requirements of aggregation, personalization, presentation, and
security for portlets running in a portal environment. Version 2.0 of the Java Portlet Specification, Java Specification
Request 286 (JSR 286), defines standards to extend the capabilities of Version 1.0 (JSR 168) to include coordination
between portlets, resource serving, and other advanced features. See JSR 186.
JSTL. See JavaServer Pages Standard Tag Library.
keyboard support. The ability for a developer to enable a user to use a physical keyboard to interact with the host
when the application is running in a Web browser or rich client environment. The developer also decides whether to
include a host keypad, an application keypad, or both, in a project. If keypads are included, the developer decides
which keys are included and how those keys and the keypad appear in the client interface.
keypad support. The ability for a developer to enable a user to interact with the host as if the physical keys on a
keyboard were pressed, or to perform tasks related to the application, such as viewing their print jobs or refreshing
the screen. See also application keypad and host keypad.
linked HATS/WebFacing project. A project created by linking a single HATS Web project with a single WebFacing
project for the purpose of creating an enterprise application that includes a HATS Web application interoperating
with a WebFacing application and sharing a connection to a 5250 backend host.
Lotus Expeditor Client. A standalone client of the Lotus Expeditor product. It is installed on a user or development
machine.
Lotus Notes Client. A standalone client of the Lotus Notes product. It is installed on a user or development
machine.
78
IBM Rational Host Access Transformation Services: Getting Started
macro. A macro, stored in a .hma file, automates interactions with the host. It can send commands to the host, enter
data into entry fields, extract data from the host, and be used to navigate screens on behalf of the user.
Model 1 Web pages. A single JSP that contains the information to be presented to the user, formatting tags that
specify how the information is displayed, and logic that controls the order in which pages are displayed. (Contrast
with Struts Web pages.)
network security layer. Software that is responsible for authenticating users and authorizing them to access network
resources, such as IBM Tivoli Access Manager.
Operator Information Area (OIA). OIA is the area at the bottom of the host session screen where session indicators
and messages appear. Session indicators show information about the workstation, host system, and connectivity.
perspective. In the Rational SDP workbench, a group of views that show various aspects of the resources in the
workbench. The HATS perspective is a collection of views and editors that allow a developer to create, edit, view,
and run resources which belong to HATS applications.
pooling. See connection pool.
portal. An integrated Web site that dynamically produces a customized list of Web resources, such as links, content,
or services, available to a specific user, based on the access permissions for the particular user.
print support. The ability for a developer to specify a printer session to be associated with a host session, and
enable the user to view host application print jobs, send them to a printer, or save them to disk. Print support is
available only for the default connection
Profile. For rich client projects, the same as Run, and in addition enables you to locate the operations that require
the most time, and identify actions that are repeated, to eliminate redundancy. You can use this function for
performance analysis, helping you to get a better understanding of your application.
Profile on Server. For Web projects, the same as Run on Server, and in addition enables you to locate the operations
that require the most time, and identify actions that are repeated, to eliminate redundancy. You can use this function
for performance analysis, helping you to get a better understanding of your application.
project. A collection of HATS resources (also called artifacts) that are created using HATS Toolkit wizards and
customized using HATS Toolkit editors. These resources are exported as a HATS application. There are five types of
HATS projects: Web, portlet, EJB, rich client, and for purposes of administering HATS Web (including portlet and
EJB) applications, HATS administrative console projects. See HATS project or HATS EJB project.
Rational Software Delivery Platform (Rational SDP). A family of IBM software products that are based on the
Eclipse open-source platform and provide a consistent set of tools for developing e-business applications.
rendering set. A rendering set is configured by creating a prioritized list of rendering items. Each rendering item
defines a specific region in which a specified host component is recognized and then rendered using a specified
widget.
resource. Any of several data structures included in a HATS project. HATS resources include templates, screen
events, transformations, screen captures, connections, and macros. Other Rational SDP plug-ins sometimes call these
"artifacts."
RESTful Web service. See Web service, RESTful.
rich client. A plug-in designed to run on the Eclipse Rich Client Platform in a client environment, and designed to
provide an enhanced user experience by the appearance and behavior native to the platform on which it is deployed.
Run. For rich client projects, a function in Rational SDP that enables you to test your HATS rich client projects in an
Eclipse, Lotus Notes, or Lotus Expeditor Client instance. In this mode you can modify and test the runtime settings,
defined in the runtime.properties file, that are deployed to the runtime environment. Be aware that any changes
made to the runtime settings while testing in this mode are retained and become effective when you deploy the
HATS application to a runtime environment.
Run on Server. For Web projects, a function in Rational SDP that enables you to test your HATS Web and portlet
projects in a WebSphere Application Server or WebSphere Portal instance, as appropriate. In this mode you can
modify and test the runtime settings, defined in the runtime.properties file, that are deployed to the runtime
Glossary
79
environment. Be aware that any changes made to the runtime settings while testing in this mode are retained and
become effective when you deploy the HATS application to a runtime environment.
runtime settings. Log, trace, and problem determination settings defined in the runtime.properties file that are
deployed to the runtime environment.
screen capture. An XML representation of a host screen, stored in a .hsc file, used to create or customize a screen
customization, screen combination, transformation, global rule, or macro. Screen captures are useful because they
enable you to develop a HATS project even when not connected to the host. They are also useful in creating macros
which are the core of HATS Integration Object and Web services support.
Screen captures of video terminal (VT) host screens can be used to create or customize a macro using the Visual
Macro Editor and as the check-in screen when configuring pooling. They cannot be used to create screen
customizations, screen combinations, transformations, default rendering, or global rules.
screen combination. A type of HATS screen event designed to gather output data from consecutive, similar host
screens, combine it, and display it in a single output page. The screen combination definition, stored in a .evnt file,
includes a set of screen recognition criteria for both the beginning and ending screens to be combined, how to
navigate from screen to screen, and the component and widget to use to recognize and render the data gathered from
each screen.
screen customization. A type of screen event designed to perform a set of actions when a host screen is recognized.
A screen customization definition, stored in a .evnt file, includes a set of criteria for matching host screens, and
actions to be taken when a host screen matches these criteria.
screen event. A HATS event that is triggered when a host screen is recognized by matching specific screen
recognition criteria. There are two types of screen events, screen customizations and screen combinations.
screen recognition criteria. A set of criteria that HATS uses to match one or more screens. When a host displays a
screen, HATS searches to determine whether the current host screen matches any of the screen recognition criteria
defined for any screen event in your project. If HATS finds a match, the defined actions for the screen event are
performed.
Screen recognition criteria are also used in the process of recording a macro; in this context they are sometimes called
descriptors.
Secure Sockets Layer (SSL). A security protocol that provides communication privacy. SSL enables client/server
applications to communicate in a way that is designed to prevent eavesdropping, tampering, and message forgery.
SSL was developed by Netscape Communications Corp. and RSA Data Security, Inc.
source. The files containing the markup language that define a HATS project or one of its resources. Also the name
of a folder contained in each HATS project.
SSL. See Secure Sockets Layer.
standard portlets. Portlets that comply with the standard portlet APIs defined by Java Portlet Specifications JSR 168
or JSR 286. See JSR 168 and JSR 286. Contrast with IBM portlets.
Standard Widget Toolkit (SWT). An Eclipse toolkit for Java developers that defines a common, portable, user
interface API that uses the native widgets of the underlying operating system.
Struts Web pages. Web pages built using the Apache Software Foundation’s Struts open-source framework for
creating Java web applications. This method of building Web pages creates class files that set values and contain
getters and setters, input and output JSPs, and a Web diagram to display the flow and logic of the Web pages.
(Contrast with Model 1 Web pages.)
SWT. See Standard Widget Toolkit.
system screen. An IBM i screen for which data description specification (DDS) display file source members are not
available. System screen is specific to an application on an IBM i platform that has been WebFaced.
template. A template, stored in a .jsp file (for Web projects) or a .java file (for rich client projects), controls the basic
layout and style, such as color and font, of the application. It also defines the appearance of areas that are common in
your GUI, such as a banner and a navigation area.
80
IBM Rational Host Access Transformation Services: Getting Started
text replacement. A HATS function used to transform text on a host system into images, HTML code, or other text
on a HATS screen transformation,
theme. A theme groups a set of common appearance and behavior characteristics for a project. These attributes can
be individually modified later.
transfer. To copy an application EAR file to the server, typically by FTP.
transformation. A transformation stored in a .jsp file (for Web projects) or a .java file (for rich client projects) defines
how host components should be extracted and displayed using widgets in your GUI.
transformation connection. See default connection.
transformation fragment. A HATS resource that contains the content with which to replace all occurrences of a
pattern in any given transformation.
Unicode. A universal character encoding standard that supports the interchange, processing, and display of text that
is written in any of the languages of the modern world. It also supports many classical and historical texts in a
number of languages. The Unicode standard has a 16-bit international character set defined by ISO 10646.
user. Any person, organization, process, device, program, protocol, or system that uses the services of a computing
system.
user list. A list containing information about accounts (user IDs) that a HATS application can use to access a host or
database. User lists contain user IDs, passwords, and descriptions for the accounts.
UTF-8. Unicode Transformation Format, 8-bit encoding form, which is designed for ease of use with existing
ASCII-based systems.
Web archive (WAR). A compressed file format, defined by the Java EE standard, for storing all the resources
required to install and run a Web application in a single file.
Web Express Logon (WEL). A HATS feature that enables users to log onto several hosts using a set of credentials
that are authenticated by a network security layer. (See network security layer.)
Web service. A self-contained, self-describing modular application that can be published and invoked over a
network using standard network protocols.
Web service, RESTful. A Web service that uses a stateless architecture and is viewed as a resource rather than a
function call. Well-formatted URIs are used to identify the Web service resource, HTTP method protocols are used to
do create, retrieve, update, and delete (CRUD) activities, and HTTP header information is used to define the message
format.
Web service, traditional, WSDL-based. A Web service where typically, XML is used to tag data, SOAP is used to
transfer data, WSDL is used for describing the services available, and UDDI is used for listing what services are
available.
WebFacing feature. The IBM WebFacing Tool for IBM i feature of the HATS Toolkit. The WebFacing feature
provides the ability to convert IBM i data description specification (DDS) display file source members into a
Web-based user interface for existing 5250 programs.
WebFaced application. A Web application produced by the WebFacing feature of the HATS Toolkit.
WebSphere. An IBM brand name that encompasses tools for developing e-business applications and middleware for
running Web applications. Sometimes used as a short name for WebSphere Application Server, which represents the
runtime half of the WebSphere family of products.
WebSphere Application Server. Web application server software that runs on a Web server and that can be used to
deploy, integrate, run, and manage e-business applications. HATS applications, when exported and transferred to a
server, run as WebSphere Application Server applications.
WEL. See Web Express Logon.
Glossary
81
widget. A reusable user interface component such as a button, scrollbar, control area, or text edit area, that can
receive input from the keyboard or mouse and can communicate with an application or with another widget. HATS
applications transform host components into widgets.
wizard. An active form of help that guides users through each step of a particular task.
workbench. The user interface and integrated development environment (IDE) in Eclipse-based products such as
Rational SDP.
XML. See Extensible Markup Language.
Various Java definitions reprinted with permission from Oracle.
82
IBM Rational Host Access Transformation Services: Getting Started
Index
A
accessibility
actions 50
HATS rich client application 2
HATS rich client project 5, 9
HATS Toolkit 1
starting 31
HATS Web application 2
HATS Web project 4, 8
host component 53
host screen preview 46
host terminal 45
HTML DDS 66
14
B
business logic
50, 61
C
coexistence 12
component 53
connection 44
content assistance
macro 12
criteria 49
I
D
default rendering 48
deploying
HATS rich client applications
HATS Web applications 67
E
editors 32
ENPTUI 65
evaluating HATS 30
exporting
HATS rich client projects 68
HATS runtime features 68
HATS Web projects 67
extended attributes 63
F
fragment, transformation
Functions
WebFacing 19
49
G
global rules 49
global variables 50, 61
H
HATS 1
HATS application 33
HATS project
creating 36
developing 36
previewing 38
testing 38
HATS Projects view 32, 43
HATS resources 43
© Copyright IBM Corp. 2002, 2013
67
icons 34, 45, 56
installation 23, 24
modifying 26
repository 27
silent 28
steps 24
uninstalling 27
silent 28
updating 25
installing
HATS rich client applications 68
Eclipse RCP 68
Lotus Expeditor Client; 69
Lotus Notes 69
HATS Web applications 67
Integration Objects 61
K
keyboard support
61
L
license settings
runtime enablement
log files 28
perspective 31
PF keys 58
portlet 7, 11
prerequisites 23
IBM Rational HATS feature 23
IBM WebFacing Tool for IBM i
feature 23
Portal support for IBM WebFacing
Tool for IBM i feature 24
preview
host screen 46
previewing
project 38
print support 62
R
Rational SDP 31
rendering, default 48
repository
installation 27
rich client
deploying HATS applications 67
exporting application feature 68
exporting HATS runtime features 68
installing HATS applications 68
Eclipse RCP 68
Lotus Expeditor Client; 69
Lotus Notes 69
update site 68
roles 13
rules, global 49
runtime enablement
license settings 28
S
macro 44, 59
content assistance 12
migration 12
mobile device support 7, 11
modifying
installation 26
screen capture 44, 46
screen combination 44, 49
creating 51
enabling 52
screen customization 44, 49
creating 50
enabling 52
screen event 44, 49
enabling 52
serviceability
IBM Support Assistant 12
subfile 62
O
T
28
M
Oracle WebLogic Server
11
P
Page Designer
Web
transformations
56
template 44, 47
testing
project 38
text replacement 58
tips 35
transformation 44, 50, 53
creating 55
editing 56
83
transformation (continued)
rich client 57
Web 56
transformation fragment 49
U
uninstalling 27
silent 28
update site
rich client 68
updating
installation 25
V
Visual Editor
rich client
transformations
57
W
Web application
deploying 67
Web applications
installing 67
Web project
exporting 67
WebFacing
What's new 22
WebFacing functions 19
WebFacing introduction 19
WebLogic 11
Welcome page 33
What's new
HATS 11
WebFacing 22
widget 53
Workstation ID 62
84
IBM Rational Host Access Transformation Services: Getting Started
Readers’ Comments — We'd Like to Hear from You
IBM Rational Host Access Transformation Services
Getting Started
Version 9.0
Publication No. GI13-2847-00
We appreciate your comments about this publication. Please comment on specific errors or omissions, accuracy,
organization, subject matter, or completeness of this book. The comments you send should pertain to only the
information in this manual or product and the way in which the information is presented.
For technical questions and information about products and prices, please contact your IBM branch office, your
IBM business partner, or your authorized remarketer.
When you send comments to IBM, you grant IBM a nonexclusive right to use or distribute your comments in any
way it believes appropriate without incurring any obligation to you. IBM or any other organizations will only use
the personal information that you supply to contact you about the issues that you state on this form.
Comments:
Thank you for your support.
Submit your comments using one of these channels:
v Send your comments to the address on the reverse side of this form.
v Send a fax to the following number: 1-800-227-5088 (US and Canada)
v Send your comments via email to: [email protected]
If you would like a response from IBM, please fill in the following information:
Name
Address
Company or Organization
Phone No.
Email address
GI13-2847-00
___________________________________________________________________________________________________
Readers’ Comments — We'd Like to Hear from You
Cut or Fold
Along Line
_ _ _ _ _ _ _Fold
_ _ _and
_ _ _Tape
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _Please
_ _ _ _ _do
_ _not
_ _ staple
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _Fold
_ _ _and
_ _ Tape
______
NO POSTAGE
NECESSARY
IF MAILED IN THE
UNITED STATES
BUSINESS REPLY MAIL
FIRST-CLASS MAIL
PERMIT NO. 40
ARMONK, NEW YORK
POSTAGE WILL BE PAID BY ADDRESSEE
IBM Corporation
Rational Enterprise Modernization UAD
Department 67RA/Building 503
Research Triangle Park, NC 27709-9990
_________________________________________________________________________________________
Fold and Tape
Please do not staple
Fold and Tape
GI13-2847-00
Cut or Fold
Along Line
Printed in USA
GI13-2847-00