HATS Web Application Frequently Asked Questions

Please refer to HATS Technotes (FAQs) for additional information.

Click any question to toggle the answer display.

  • Is there a HATS equivalent of the Host Publisher "Application Integrator" for creating Integration Objects?

    Page Designer is a toolkit in the IBM Software Delivery Platform (SDP) where you can edit JavaServer Pages (JSP) and design and create Web pages.

    HATS extends this page designer functionality to enable you to insert inputs and outputs of your Host Publisher Integration Objects into JSP files, much like the Application Integrator. You can create an application to run chained Integration Objects using Page Designer along with HATS Insert Integration Object inputs/outputs action menu items found under the HATS Tools menu.

  • Where are the Integration Objects, Struts, Model 1 and JSF folders?

    Integration Objects, Struts, Model 1, and JSF Pages are advanced HATS features and their folders are hidden unless they contain files.

    Integration Objects are located in the Source > IntegrationObject folder in the HATS Projects view.

    Struts files are located in the Web Content > Struts Pages folder, Source > Struts > Actions folder, and Source > Struts > ActionForms folder in the HATS Projects view.

    Model 1 files are located in the Web Content > Model 1 Pages folder in the HATS Projects view.

    JSF files are located in the Web Content > JSF Pages folder in the HATS Projects view.

  • I have some JavaServer Pages (JSP) that use Integration Objects created in Host Publisher V4 and are imported into HATS. In Host Publisher, you could use Host Access to modify or debug the Integration Object (macro). How do I modify an existing macro in HATS?

    If you want to change the host interaction, you need to modify or re-record a macro to run the interaction, then use HATS to generate an Integration Object from the macro.

  • What should I do if I receive a "message file is broken" error message and I'm unable to compile a JavaServer Page (JSP)?

    Large JavaServer Pages (JSP) might give the following message in the WebSphere Application Server log:

    JAVAC MESSAGE FILE IS BROKEN: key=javac.err.branch.too.big at runtime

    If this occurs, follow these steps:

    1. Set the JVM system property to true: com.sun.tools.javac.main.largebranch = true
    2. Restart the server and request the JSP again.

    JVM properties can be set using the Administrative console to set up arguments for the Java Virtual Machine (JVM) or by creating a Custom Property.

  • In my default transformation, how do I cause the function keys to be rendered in a location that differs from where the host screen shows them?

    If having the function keys rendered as static text in their original location is not a concern, it is easy. Edit the default rendering set to disable function key rendering, which enables the field component to render text such as F3=Exit as simple static text.

    If you want function keys rendered as buttons or links, edit the default transformation JSP to add the function key component, and select the desired widget. Place this second component where you want to see the function keys rendered. You can also limit the region of the host screen to be scanned for function keys.

    If function keys must be hidden and only displayed as buttons or links, and in a different location from where the host shows them, there is more work to do. One option is to update the default transformation, default.jsp, to only transform the first 21 rows of the screen with default rendering, and render the last three rows with a HATS:Component tag. This tag can be positioned anywhere within the transformation.

    To use this option, follow these steps:

    1. Open default.jsp by clicking the HATS Projects view in the HATS Toolkit, expand the project name, and expand Web Content > Transformations.
    2. Locate the <HATS:DefaultRendering /> tag and change it to read: <HATS:DefaultRendering row="1" col="1" erow="21" ecol="-1" />
    3. Manually add a host component by selecting HATS Tools > Insert Host Component and draw a box around the last three screen rows.
    4. Select the function key component and the appropriate widget, such as link or drop-down menu.
    5. Position this tag any place within the default.jsp, for example, above the default rendering tag or to the left as a drop-down menu: <HATS:Component type="com.ibm.hats.transform.components.FunctionKeyComponent" widget="com.ibm.hats.transform.widgets.SLDropdownWidget" row="22" col="1" erow="24" ecol="80" componentSettings="" widgetSettings="" textReplacement="" /> This solution has its drawbacks, however. Because the HATS:DefaultRendering tag is only rendering the first 21 rows of the screen, error messages that might appear in the last three rows of a screen will not be displayed. Also, other fields, such as input fields, will not be displayed.

    Another solution avoids this problem, but you will need to write some code. The idea is pretty simple. The function key component in the default rendering must recognize the function keys before the field component does. If not, the field component will render them.

    To use this option, follow these steps:

    1. Write a renderNothing widget that simply returns an empty string in the renderHTML method.
    2. Modify the default rendering set to render the function keys with this new widget instead of the link widget or button widget.
    3. Edit the default transformation JSP and ensure that the function key component recognizes the function keys and renders them as links or buttons in the location where you want them to appear. The function key component in the default rendering must recognize the function keys and suppress them (with the renderNothing widget), but still let other components recognize anything else that might be there.
    4. Recognize the function keys again and render them where you like.

    If you wish to do this sort of thing with a custom transformation, create a custom transformation that uses the default rendering. Edit the custom transformation JSP instead of the default transformation JSP. You should also create a custom rendering set and edit it to suppress the function key rendering. You can copy the default rendering set as a starting point.

  • How do I make individual HATS components appear side-by-side on the output page?

    HATS widgets render output in HTML tables. When you insert one HATS component immediately after another in a transformation, the components are contained within <TABLE></TABLE> HTML tags and a Web browser displays the tables as one directly under the other. To make the components appear side-by-side, you have two options:

    1. When creating a transformation, choose Prepopulated using default rendering on the rendering options of the Create a Transformation Wizard. This option inserts components in an HTML table and attempts to preserve side-by-side orientation when transforming host screens.
    2. You can create a table in the JavaServer Page (JSP) and insert the HATS components into the individual cells of the table. The Rational Software Delivery Platform (SDP) JSP editor has numerous tools for assisting with this, but the toolbars are turned off by default. If you prefer to use toolbars, you need to select them in the Toolbars menu.
  • How do I link to a Host Publisher input page from a HATS transformation page and automatically share the existing host connection?

    You need to use the Forward to URL action, described in the User's and Administrator's Guide. This action enables you to pass control from a transformation-oriented HATS project to a JavaServer Page (JSP) that invokes one or more chained Integration Objects.

    If you want to have the Integration Object use the same connection, the Integration Object must be created as a chained Integration Object, and not the first-in-chain, otherwise the Integration Object code creates a new connection instead of sharing the HATS transformation connection. Note that by right clicking on a HATS macro, you can create an Integration Object that plays the particular macro.

  • What happens when you are accessing a HATS application and you press the browser back button?

    When you press the back button on a page (let's call it page n), you see the previous transformation page (n-1), prefilled with the data that you entered on page n-1, that caused page n to appear. In addition, the browser forward button is now enabled. Note, however, that the terminal application is still on the host screen associated with page n.

    If you ignore the visual indicators showing that you have been on page n-1 before, and you enter data into the input fields or press a function key, results are unpredictable.

    The behavior described above is working as designed, since users might want to return to the previous screen.

    However, here are some alternatives to explore if you do not want users to be able to go back in the HATS application:

    1. Have the HATS application open in a window without a toolbar. The window.open JavaScript method enables you to specify whether the browser toolbar should be displayed.
    2. Start the browser without a toolbar or with a customized toolbar. For example, launch Internet Explorer in kiosk or full screen mode, or launch Opera with a specific configuration.