This book provides the information you need to understand the IBM® 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.
With HATS, you can create Web applications 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 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, visit IBM Knowledge Center at http://www.ibm.com/support/knowledgecenter/SSKTMJ_8.5.3. For more information about the Lotus Expeditor Client, visit IBM Knowledge Center at http://www.ibm.com/support/knowledgecenter/SSVHEW_6.2.0.
HATS has two components:
The HATS Toolkit enables you to develop new applications, previewing and saving each change you make. Over time, or as quickly as you like, you can streamline your HATS application, making it easier 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.
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.
The following figure shows the stages of development, deployment, and runtime for a HATS rich client application.
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:
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:
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:
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 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:
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:
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 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:
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.
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 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:
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:
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:
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:
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:
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 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:
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.
HATS V9.6 extends the supported application development environment to Rational SDP V9.6. New HATS runtime environments include WebSphere Application Server V8.5.5 and Eclipse V4.4.
HATS V9.6 does not support Rational SDP V9.0 or WebSphere Application Server V6.1.
For up-to-date support considerations, see "IBM Host Access Transformation Services 9.6 - Known issues and workarounds" at http://www.ibm.com/support/docview.wss?uid=swg27050242.
Along with WAS, users can now create and deploy HATS RESTful services using Liberty and Geronimo Runtimes. To enable JAX-RS 1.X runtime please follow the instructions from respective application server's documentation.
Using HATS RESTful service interfaces, users can enable or disable swagger support while creating/updating RESTful services. Using HATS runtime, users can access the swagger description document for the RESTful service(s). This provides a mechanism for HATS RESTful APIs to participate in API management to be able to publish APIs for consumption by end-users.
HATS RESTful services with Swagger support is added for WAS, Liberty and, Geronimo.
Develop and publish HATS EARs to WebSphere Application Server traditional v9.
HATS extends Rich Page Editor to customize jsp files of HATS projects. Rich Page Editor is a multi-tabbed editor that provides multiple views to show different representations of your page. For more details about Rich Page Editor, refer to RAD Rich Page Editor.
HATS transformation pages are HTML5 compliant. HTML 5 unsupported tags/attributes have been replaced with alternative tags/attributes/CSS.
A new option "Add Input Attributes" has been added in input widget settings. This helps users to add any attribute value pair(s) to HATS generated input fields either through screen customization or global rules.
With HATS 9.6, support for creation of HATS EJB Project has been removed. This reduces footprint for HATS and improves performance.
Replacement/Alternatives:
With HATS 9.6, Page Designer component has been removed, since Rational Application Developer stopped supporting it. It has been replaced by Rich Page Editor.
Cross-Site Request Forgery (CSRF) attack, that occurs when a malicious website, email, blog, instant message, or program causes a user's web browser to perform an unwanted action on a trusted site for which the user is currently authenticated, can be prevented using the two new CSRF attack prevention techniques introduced in HATS v9.6.1 :
XSS Security Policy is supported by HATS, and users can choose to enabled one of the three policies :
HATS supports JBoss EAP server, and users can develop, test, run and deploy HATS web applications on JBoss EAP server.
Few known issues and work-arounds (JBoss considerations) include :
For up-to-date support considerations, see "IBM Host Access Transformation Services 9.6 - Known issues and workarounds" at http://www.ibm.com/support/docview.wss?uid=swg27050242.
HATS supports the Window Builder for Rich client applications, by using the SWT Designer (Window Builder) for visual UI design.
HATS Clients can accept certificate authorities trusted by the Microsoft Internet Explorer browser by selecting this option.
HATS V8.5, V9.0, V9.5 and V9.6 can coexist, within their own individually supported Rational SDP offerings, on the same development system with HATS V9.6. It is also possible for HATS V9.6 to be installed multiple times on the same system. If you have multiple supported Rational SDP offerings installed on your system, HATS V9.6 can be installed into each of them.
If you are a Host Publisher V4, HATS V5, V6, V7.0, V7.1, V7.5, V8.0, V8.5, V9.0, or V9.5 user, you can migrate your projects to HATS V9.6.
HATS V4 LE, HATS V5 LE, and HATS V4 projects cannot be migrated directly to HATS V8.0, V8.5, V9.5 or V9.6. 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, V9.0, V9.5 or V9.6. See the documentation for your previous release of HATS for information about migrating HATS projects.
For more information about migrating to HATS V9.6, see the HATS User's and Administrator's Guide
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 Knowledge Center, home page, support site, education assistant site, and other sites. You can search these sites for information that may help you resolve a problem. For information about how to install the HATS plug-in, see the section, Use the IBM Support Assistant, in HATS Troubleshooting.
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:
A user of the HATS Toolkit. The developer creates and edits a HATS Web application using Rational SDP and the HATS perspective.
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.
A user of the HATS Toolkit. The developer creates and edits a HATS rich client application using Rational SDP and the HATS perspective.
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.
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 resulting host session to work with a host application. The rich client-based user clicks an icon that will establish a host session.
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.
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.
The person responsible for installing, provisioning, and deploying HATS rich client applications.
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.
Independent software developers use the HATS Toolkit to create custom applications that are resold to other customers.
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:
Keep the following in mind when using HATS:
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:
For more information about accessibility, refer to the following Web sites:
The following HATS information is available before you install HATS:
In addition to the information available before installing HATS, the following information is available on the system after installing HATS: