Sample modified Integration Object template
This sample template illustrates the addition of new code to Integration Object templates, in order to add new function to the Integration Objects that will be generated from it. This sample template is based on the default template provided by ZIETrans. See Sample modified Integration Object template for a description of the additions in this template.
////////////////////////////////////////////////////////////////////////////////
// begin add for HPubExtractFieldAttributes
//
//
// ZIETrans Customized template that obtains all planes for extracted data
// when customreco tag specifying HPubExtractFieldAttributes is coded in the macro
//
// This software is provided AS IS.
// Permission to use, copy and modify this software for any purpose and
// without fee is hereby granted.provided that the name of IBM not be used in
// advertising or publicity pertaining to distribution of the software without
// specific written permission.
//
// IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.IN NO EVENT SHALL IBM
// BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
// DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
// IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
// OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// end add for HPubExtractFieldAttributes
////////////////////////////////////////////////////////////////////////////////
%Global
package %9%;
%End
// Host On-Demand support
import com.ibm.eNetwork.beans.HOD.*; // HOD JavaBeans
import com.ibm.eNetwork.beans.HOD.event.*; // HOD JavaBeans events
import com.ibm.eNetwork.beans.HOD.trace.*; // HOD JavaBeans trace
import com.ibm.eNetwork.ECL.*; // Host Access Class Library
// begin add for HPubExtractFieldAttributes
import com.ibm.eNetwork.ECL.screenreco.event.ECLCustomRecoEvent;
// end add for HPubExtractFieldAttributes
//import ZIETrans Session Manager classes
import com.ibm.hats.runtime.connmgr.*;
import com.ibm.hats.runtime.*;
import com.ibm.HostPublisher.IntegrationObject.*;
import com.ibm.hats.util.*;
import com.ibm.hats.common.connmgr.*;
import com.ibm.hats.common.ResourceLoader;
import com.ibm.hats.common.HMacro;
import com.ibm.hats.common.CommonConstants;
import com.ibm.hats.common.customlogic.HatsCustomListener;
import com.ibm.hats.common.wel.SSOMacro;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.io.*;
import java.lang.reflect.*;
import java.beans.*;
import java.util.zip.*;
import org.w3c.dom.Document;
import javax.servlet.*;
%Global
public class %1% extends HPubHostAccess implements
%End
MacroRuntimeListener,
MacroCustomActionListener ,
MacroParseListener,
MacroTracerListener,
TraceListener,
Serializable,
Runnable
{
// Do not change the following 2 values
public static float getIOTemplateVersion() { return 8.0F; } // Template version
public static String getIOTemplateType() { return "-CUSTOMIZED"; } // Template type - Host Customizable
// begin add for HPubExtractFieldAttributes
public static String getIOTemplateRevision() { return ":1.2"; } // Template revision - internal value
// end add for HPubExtractFieldAttributes
// Version information for Integration Object problem determination
// -- update this string to whatever value you like if you customize the template
// -- the full IO version string is written to traces
public static String getIOVersionInfo() { return ""; } // Customizable version info
public String hPubIOVersion= getIOBaseVersion()+";"+getHPubBeanType()+
getIOTemplateType()+getIOTemplateVersion()+
getIOTemplateRevision()+getIOVersionInfo();
public String getIOVersion() { return hPubIOVersion; }
// Bean State Constants
public static final int MACRO_STATE_NOT_INSTANTIATED = 0;
public static final int MACRO_STATE_INSTANTIATED = 1;
public static final int MACRO_STATE_READY_TO_PLAY = 2;
public static final int MACRO_STATE_PLAYING = 3;
public static final int MACRO_STATE_PARSE_ERROR = 4;
public static final int MACRO_STATE_PLAY_FINISHED = 5;
int intMacroState = MACRO_STATE_NOT_INSTANTIATED;
// File Separator - used to locate macro file
static String staticstringFileSeparator = new String(System.getProperty("file.separator"));
boolean booleanFirstTimeHere = true;
// Vector of Generated Objects
public Vector vHAOVariables = new Vector();
// HostPublisher Session Manager objects
transient HodConn oConn = null;
// HOD objects
Macro macroBean = null;
Session sessionHost = null;
String stringMacroName = null;
transient ECLSession eclsessionHost = null;
static MacroScreens oMacroScreens = null;
boolean welCorrelatorsUsed = false;
// Synchronize access of macro file
static Object oSyncObject = new Object();
// Variable to determine processing of HOD extract events
int intCodePage = 0;
String stringCodePage = null;
boolean booleanDBCSCodePageInUse = false;
// Variables used to make known the bean's status
public String hPubScreenState = null;
public String hPubMacroMessage = null;
// HOD Error Message holder
public String stringHODMacroError = null;
// Generated Objects
%HAO_Variable_Definition
HAOVariable %1% = new HAOVariable("%2%","%3%","%1%",%4%,"%5%",%6%,%7%,%8%,%9%,%12%,%13%,HAO_VARIABLE_SIMPLE);
%End
%HAO_Variable_Vector_Definition
HAOVariable %1% = new HAOVariable("%2%","%3%","%1%",%4%,"%5%",%6%,%7%,%8%,%9%,%12%,%13%,HAO_VARIABLE_ARRAY);
%End
%Global
public static final String stringHODMacroFilename = "%3%";
public String stringBeanName = new String("%1%");
%End
// Constructor
%Global
public %1%()
%End
{ // Generated vector population
%HAO_Variable_Definition
vHAOVariables.addElement(%1%);
%End
%HAO_Variable_Vector_Definition
vHAOVariables.addElement(%1%);
%End
hPubBeanType = new String("HOD");
%Global
hPubBeanName = new String("%1%");
%End
%Global
%If %5% == pool
hPubStartPoolName = new String("%6%");
hPubStartChainName = null;
hPubStartType = BEAN_START_FROM_POOL;
%Endif
%If %5% == connection
hPubStartPoolName = null;
hPubStartChainName = new String("%6%");
hPubStartType = BEAN_START_FROM_CONNECTION;
%Endif
%If %7% == pool
hPubEndChainName = null;
hPubEndType = BEAN_END_TO_POOL;
%Endif
%If %7% == connection
hPubEndChainName = new String("%8%");
hPubEndType = BEAN_END_TO_CONNECTION;
%Endif
%End
}
// *************************************************************************
/* Generated Setters */
%HAO_Variable_Definition
%If %4% == true
public void set%11%( String stringToBe)
{
hPubErrorOccurred = 0;
allowTracing(); // call made in case started from IDE and was not able to
// start tracing on the constructor
if (HPubTracingOn) { Ras.traceEntry( className,"set%11%(String)", stringToBe); }
%1%.stringValue = stringToBe;
}
%Endif
%End
/* Generated Getters */
%HAO_Variable_Definition
public String get%11%()
{
hPubErrorOccurred = 0;
if (HPubTracingOn) { Ras.trace( className,"get%11% simple: ", %1%.stringValue); }
return (%1%.stringValue);
}
%End
%HAO_Variable_Vector_Definition
public synchronized String get%11%(int i)
{
hPubErrorOccurred = 0;
if ( (%1%.oMultiValues.size() != 0)
&&(i >= 0)
&&(i < %1%.oMultiValues.size())
)
{
if (HPubTracingOn)
{ Integer integerX = new Integer(i);
Ras.trace( className,"get%11% array: ",
integerX.toString(), (String) %1%.oMultiValues.elementAt(i));
}
return ( (String) %1%.oMultiValues.elementAt(i));
}
else
{ if (HPubTracingOn)
{
Integer integerX = new Integer(i);
Ras.trace( className,"get%11% array element ", "Throwing out of bounds on iteration: ",
integerX.toString());
}
throw new ArrayIndexOutOfBoundsException("Row is Out of Bounds");
}
}
public String[] get%11%()
{
hPubErrorOccurred = 0;
if (HPubTracingOn) { Ras.trace( className,"get%11% ", "array all"); }
%1%.oStringArray = new String[%1%.oMultiValues.size()];
%1%.oMultiValues.copyInto(%1%.oStringArray);
return (String[])%1%.oStringArray.clone();
}
%End
public String getHPubScreenState()
{ // Name of the HOD Macro screen when a macroStateEvent was received
// and the macro state was STATE_STOPPED, STATE_PLAYING, or STATE_PLAY_ERROR
hPubErrorOccurred = 0;
if (HPubTracingOn) { Ras.trace( className,"getHPubScreenState: ", hPubScreenState); }
return hPubScreenState;
}
public void setHPubScreenState(String stringToBe)
{ // Name of the HOD Macro screen when a macroStateEvent was received
// and the macro state was STATE_STOPPED, STATE_PLAYING, or STATE_PLAY_ERROR
hPubErrorOccurred = 0;
hPubScreenState = stringToBe;
if (HPubTracingOn) { Ras.trace( className,"setHPubScreenState: ", hPubScreenState); }
}
public String getHPubMacroMessage()
{ // The getMessage string receive from the HOD Macro on the
// latest macroMessageEvent.
hPubErrorOccurred = 0;
if (HPubTracingOn) { Ras.trace( className,"getHPubMacroMessage: ", hPubMacroMessage); }
return hPubMacroMessage;
}
public void setHPubMacroMessage(String stringToBe)
{ // The getMessage string receive from the HOD Macro on the
// latest macroMessageEvent.
hPubErrorOccurred = 0;
hPubMacroMessage = stringToBe;
if (HPubTracingOn) { Ras.trace( className,"getHPubMacroMessage: ", hPubMacroMessage); }
}
// *************************************************************************
public void DoTheWork()
{ // This is the main method for the bean. In this method the bean will
// acquire a session to the host and invoke the HOD macro. Events
// fired by the HOD subsystem will be used to communicate with the
// macro and host.
HMacro hmacro;
int index;
ResourceLoader resLoader;
if (HPubTracingOn)
{ Ras.traceEntry( className,"DoTheWork");
}
hPubErrorException = null;
hPubErrorOccurred = 0;
if (booleanFirstTimeHere == true)
{ booleanFirstTimeHere = false;
}
else
{ // reset output variables if bean is being called multiple times.
resetCurrentVariableValues();
}
try
{ // Call extended class to get a HostPublisher session. It will handle exceptions and
// return null if there is a problem
oConn = (HodConn) acquireSessionFromSessionManager(stringBeanName);
if (oConn == null)
{ // Trace and Log Error
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
oErrorsToLog.handleMessage(stringBeanName, className,
"DoTheWork", "HodConn_Error_1", HPubTracingOn);
if (HPubTracingOn) { Ras.traceExit( className,"DoTheWork"); }
return;
}
// Get the HOD session
sessionHost = oConn.getConnection();
if (sessionHost == null)
{ // Log and Trace the Error
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
oErrorsToLog.handleMessage(oHttpServletRequest, stringBeanName, className,
"DoTheWork", "BeanConn_Error_3", HPubTracingOn);
// return session back to source
releaseSessionToSessionManager(BEAN_END_TO_POOL);
// invoke error page
hPubErrorOccurred = 1;
responseWithErrorKey("BeanConn_Error_3");
if (HPubTracingOn) { Ras.traceExit( className,"DoTheWork"); }
return;
}
// Get the HOD ECL session to determine if the code page being used is DBCS
eclsessionHost = sessionHost.getECLSession();
intCodePage = eclsessionHost.GetCodePage();
if (intCodePage == 37)
{ // Need 37 to convert to "037"
stringCodePage = "037";
}
else
{ Integer integerTemp = new Integer(intCodePage);
stringCodePage = integerTemp.toString();
}
if (isDBCSCodePage(stringCodePage))
{ booleanDBCSCodePageInUse = true;
}
else
{ booleanDBCSCodePageInUse = false;
}
if (HPubTracingOn) { Ras.trace( className,"DoTheWork","Instantiate a HOD Macro object"); }
macroBean = new Macro();
intMacroState = MACRO_STATE_INSTANTIATED;
stringMacroName = new String(stringHODMacroFilename);
if (stringMacroName.endsWith(".macro"))
{
index = stringMacroName.lastIndexOf(".macro");
stringMacroName = stringMacroName.substring(0,(index));
}
else if (stringMacroName.endsWith(".hma"))
{
index = stringMacroName.lastIndexOf(".hma");
stringMacroName = stringMacroName.substring(0,(index));
}
synchronized(this)
{ try
{ // listen for HOD Macro and Custom events for this macro
macroBean.addMacroRuntimeListener(this);
macroBean.addMacroCustomActionListener(this);
// Query the Host Publisher trace settings for HOD
HODRasSettings oHODRasSettings = HODRas.getHODRasSettings();
try
{
if (oHODRasSettings != null)
{ macroBean.setTraceLevel(oHODRasSettings.getMacroTracingLevel());
macroBean.addTraceListener(this);
}
// Support additional trace points in HOD macros
if ((oHODRasSettings.getMacroTracingLevel() != 0) ||
(oHODRasSettings.getUserMacroTracingLevel() != 0))
{
Macro.setMacroTracer(true);
if ( oHODRasSettings.getMacroTracingLevel() == HODRas.MACRO_TRACER_LEVEL_2)
Macro.setMacroTracerLevel(HODRas.MACRO_TRACER_LEVEL_2);
else
Macro.setMacroTracerLevel(HODRas.MACRO_TRACER_LEVEL_1);
Macro.addMacroTracerListener(this);
}
}
catch (PropertyVetoException pvEx)
{
// ignore
}
synchronized(oSyncObject)
{ // Synchronize in order to avoid concurrent access to the global parameters
// (oMacroScreens).
if (oMacroScreens != null)
{
if (HPubTracingOn){ Ras.trace( className,"doTheWork", "Macro has already been parsed"); }
macroBean.setParsedMacro( (MacroScreens) oMacroScreens.clone());
}
else
{
if (HPubTracingOn){ Ras.trace( className,"doTheWork","Get macro"); }
if (HPubTracingOn){ Ras.trace( className,"doTheWork", "Reading Macro from Disk and Parsing"); }
// Locate the file name of the HOD macro that is being used with this bean.
// Can not make this part of the bean's jar file due to unicode considerations.
resLoader = new ResourceLoader(new IOResourceProvider(this));
hmacro = resLoader.getMacro(
(oHttpServletRequest != null) ? oHttpServletRequest.getContextPath() : null, stringMacroName);
if (hmacro != null)
{
macroBean.addMacroParseListener(this);
if (HPubTracingOn){ Ras.trace( className,"doTheWork", "Set Macro and get parsed Macro Screens"); }
macroBean.setMacro(hmacro.getMacro());
macroBean.setInitialPrompt(true);
oMacroScreens = macroBean.getParsedMacro();
}
else
{
ResourceBundle res = ResourceBundle.getBundle("com.ibm.HostPublisher.IntegrationObject.HPub_Resources",
Locale.getDefault());
// Log and Trace the Error
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
String stringTemp1 = new String(res.getString("Macro_File_Name"));
oErrorsToLog.concatAndAddStrings(stringTemp1, stringMacroName);
oErrorsToLog.handleMessage(oHttpServletRequest, stringBeanName,
className, "DoTheWork", "Internal_Error_1", HPubTracingOn);
releaseSessionToSessionManager(BEAN_END_TO_POOL);
// invoke error page
hPubErrorOccurred = 1;
responseWithErrorKey("Internal_Error_1");
if (HPubTracingOn) { Ras.traceExit( className,"DoTheWork"); }
return;
}
}
}
sessionHost.addCommListener(macroBean);
if (intMacroState == MACRO_STATE_INSTANTIATED)
{ if (HPubTracingOn)
{ Ras.trace( className,"DoTheWork","Waiting for macro state event STATE_STOPPED to fire");
}
// wait for a macroStateEvent with STATE_STOPPED before continuing.
wait();
}
else
{ if (HPubTracingOn) { Ras.trace( className,"DoTheWork","Ready to play macro"); }
}
}
catch(InterruptedException oException)
{ // Log and Trace the Error
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
oErrorsToLog.handleException(oException, oHttpServletRequest, stringBeanName,
className, "DoTheWork", "Interrupted_Error_1", HPubTracingOn);
releaseSessionToSessionManager(BEAN_END_TO_POOL);
// invoke error page
hPubErrorOccurred = 1;
responseWithErrorKey("Interrupted_Error_1");
if (HPubTracingOn) { Ras.traceExit( className,"DoTheWork"); }
return;
}
}
if (intMacroState == MACRO_STATE_READY_TO_PLAY)
{ // To avoid a possible deadlock with HOD when a macro error occurs, the play() will
// be moved outside of the synchronized block and the state variable will be used
// to avoid errant processing on our part.
if (HPubTracingOn) { Ras.trace( className,"DoTheWork","Call Macro.play()"); }
intMacroState = MACRO_STATE_PLAYING;
registerCustomScreenListeners(macroBean);
// If the connection supports Web Express Logon, then the macro
// may contain Java function calls that need access to the HttpServletRequest which
// is driving this connection/macro. Must store this info for WEL.
HodConnSpec connSpec = (HodConnSpec) oConn.getSpec();
if ((connSpec != null) && (connSpec.isWelEnabled()))
{
com.ibm.hats.common.wel.SSOMacro.storeCorrelators( /*ECLSession*/ eclsessionHost,
/*HttpServletRequest*/ oHttpServletRequest,
/*HodConnSpec*/ connSpec );
welCorrelatorsUsed = true;
}
// Play the macro - what we're here for!
macroBean.play();
synchronized(this)
{ if (intMacroState != MACRO_STATE_PLAY_FINISHED)
try
{ wait();
}
catch(InterruptedException oException)
{ // Trace and Log Error
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
oErrorsToLog.handleException(oException, oHttpServletRequest, stringBeanName,
className, "DoTheWork", "Interrupted_Error_1", HPubTracingOn);
releaseSessionToSessionManager(BEAN_END_TO_POOL);
// invoke error page
hPubErrorOccurred = 1;
responseWithErrorKey("Interrupted_Error_1");
if (HPubTracingOn) { Ras.traceExit( className,"DoTheWork"); }
return;
}
}
}
}
// catch MacroException here
catch (MacroException oException)
{ // Trace and Log Error
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
oErrorsToLog.handleException(oException, oHttpServletRequest, stringBeanName,
className, "DoTheWork", "HOD_Macro_Error_1", HPubTracingOn);
releaseSessionToSessionManager(BEAN_END_TO_POOL);
// invoke error page
hPubErrorOccurred = 1;
responseWithErrorKey("HOD_Macro_Error_1");
if (HPubTracingOn) { Ras.traceExit( className,"DoTheWork"); }
return;
}
catch (Exception oException)
{ // Trace and Log Error
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
oErrorsToLog.handleException(oException, oHttpServletRequest, stringBeanName,
className, "DoTheWork", "Internal_Error_1", HPubTracingOn);
releaseSessionToSessionManager(BEAN_END_TO_POOL);
// invoke error page
hPubErrorOccurred = 1;
responseWithErrorKey("Internal_Error_1");
if (HPubTracingOn) { Ras.traceExit( className,"DoTheWork"); }
return;
}
// If the connection supports Web Express Logon, we previously
// stored correlators for use by a WEL-enabled macro. Cleanup of the macro
// means we cleanup the correlators.
finally
{
if (welCorrelatorsUsed) // we know then that wel is enabled and we've got a session object
com.ibm.hats.common.wel.SSOMacro.removeCorrelators( /*ECLSession*/ eclsessionHost);
}
releaseSessionToSessionManager(hPubEndType);
if (stringHODMacroError != null)
{ hPubErrorOccurred = 1;
responseWithErrorKey(stringHODMacroError);
}
if (HPubTracingOn) { Ras.traceExit( className,"DoTheWork"); }
}
// *************************************************************************
public void resetCurrentVariableValues()
{ // This bean can be called (using the DoTheWork method) multiple times
// without having to be instantiated each time. Therefore the output
// values need to be reset upon each call.
HAOVariable haovWorkOnThis;
if (HPubTracingOn)
{ Ras.traceEntry( className,"resetCurrentVariableValues");
}
hPubErrorOccurred = 0;
hPubScreenState = null;
for (int i=0; i < vHAOVariables.size(); i++)
{ haovWorkOnThis = (HAOVariable) vHAOVariables.elementAt(i);
if (haovWorkOnThis.intVariableType == HAO_VARIABLE_SIMPLE)
{ // simple variable
if (haovWorkOnThis.booleanInputVariable == false)
{ // if variable is output, reset null
// if variable is input, leave value as is.
haovWorkOnThis.stringValue = null;
}
}
else
{ // vector variable
// Garbage collect
haovWorkOnThis.oMultiValues = null;
// Set up new vector
haovWorkOnThis.oMultiValues = new Vector();
}
}
if (HPubTracingOn)
{ Ras.traceExit( className,"resetCurrentVariableValues");
}
}
// *************************************************************************
public void releaseSessionToSessionManager(int intEndType)
{
// Releaase the session back to the HostPublisher Subsystem and
// perform general clean up.
if (HPubTracingOn) { Ras.traceEntry( className,"releaseSessionToSessionManager"); }
try
{ if (sessionHost != null)
{ if (HPubTracingOn)
{ Ras.trace( className,"releaseSessionToSessionManager","Release HOD Session object");
}
// remove the HOD session listeners
sessionHost.removeCommListener(macroBean);
sessionHost = null;
}
if (macroBean != null)
{ if (HPubTracingOn)
{ Ras.trace( className,"releaseSessionToSessionManager","Release HOD Macro object");
}
// remove the HOD Macro listeners
macroBean.removeMacroParseListener(this);
macroBean.removeMacroCustomActionListener(this);
Macro.removeMacroTracerListener(this);
macroBean.removeMacroRuntimeListener(this);
macroBean.dispose();
macroBean = null;
}
}
catch (MacroException oException)
{ // ignore, because we are attempting to clean up.
}
if (oConn != null)
{ if (HPubTracingOn)
{ Ras.trace( className,"releaseSessionToSessionManager","Release HPub connection object");
}
try
{ switch (intEndType)
{ case BEAN_END_TO_POOL:
// Release the session back to HostPublisher
Ras.trace( className,"releaseSessionToSessionManager","Release To Pool");
oConn.releaseConnectionToSource(oHttpServletRequest, this);
break;
case BEAN_END_TO_CONNECTION:
if ( (intStartMethod == START_FROM_EVENT)
||(intStartMethod == START_FROM_PROCESSREQUEST)
)
{ Ras.trace( className,"releaseSessionToSessionManager","Release From NON-Web session");
if (hPubLinkKey == null)
{ Ras.trace( className,"releaseSessionToSessionManager","No link key - seed key with oConn.getTitle()");
if (hPubStartType == BEAN_START_FROM_POOL)
{ hPubLinkKey = oConn.getTitle();
oConn.saveConnectionWithKey(hPubLinkKey, hPubEndChainName, this);
}
else
{ Ras.trace( className,"releaseSessionToSessionManager","Error No link key when bean released from a chain");
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
oErrorsToLog.handleMessage(oHttpServletRequest, stringBeanName, className,
"releaseSessionToSessionManager", "BeanConn_Error_5", HPubTracingOn);
// invoke error page
hPubErrorOccurred = 1;
responseWithErrorKey("BeanConn_Error_5");
}
}
else
{ Ras.trace( className,"releaseSessionToSessionManager","link key provided:", hPubLinkKey);
oConn.saveConnectionWithKey(hPubLinkKey, hPubEndChainName, this);
}
}
else
{
// If we are passing the connection to the ZIETrans entry servlet,
// we need to insure that the connection is not returned to the
// connection pool. Also, if no chaining is occurring, then
// add a predefined label to be used when the connection is saved.
if ((getHPubSaveConnOnError() == true) &&
(isTransformConn() == true))
{
String label;
if (hPubEndChainName == null)
label = CommonConstants.PARAM_NO_CHAINING;
else
label = hPubEndChainName;
oHttpServletRequest.setAttribute(CommonConstants.ZIETrans_EXISTING_CONN, label);
oConn.saveConnectionInWebsession(oHttpServletRequest, label, this);
}
else
{
// Normal chain processing
oConn.saveConnectionInWebsession(oHttpServletRequest, hPubEndChainName, this);
}
}
break;
}
oConn = null;
cleanupHPubCommon();
}
catch (ConnException oException)
{ // Trace and Log Error
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
oErrorsToLog.handleException(oException, oHttpServletRequest, stringBeanName,
className, "releaseSessionToSessionManager", HPubTracingOn);
}
}
if (HPubTracingOn) { Ras.traceExit( className,"releaseSessionToSessionManager"); }
return;
}
// *************************************************************************
protected void finalize()
{
if (HPubTracingOn) { Ras.traceEntry( className,"finalize"); }
releaseSessionToSessionManager(BEAN_END_TO_POOL);
if (HPubTracingOn) { Ras.traceExit( className,"finalize"); }
}
// *************************************************************************
public void parseFailed(MacroParseEvent eventParseError)
{ // HOD parse event fired for this macro
// Not that our macros would fail to parse, but if the user hand-modified
// a macro, we need to catch the error here
// Log and trace the error
MacroParseStat mpStat;
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
if (HPubTracingOn) { Ras.traceEntry( className,"parseFailed"); }
ResourceBundle res = ResourceBundle.getBundle("com.ibm.HostPublisher.IntegrationObject.HPub_Resources",
Locale.getDefault());
intMacroState = MACRO_STATE_PARSE_ERROR;
if (macroBean != null)
{ String stringTemp1 = new String(res.getString("Macro_Name"));
oErrorsToLog.concatAndAddStrings(stringTemp1, stringMacroName);
}
oErrorsToLog.handleMessage(oHttpServletRequest, stringBeanName, className,
"parseFailed", "HOD_Macro_Parse_Error_1", HPubTracingOn);
for (Enumeration e = eventParseError.parseStats(); e.hasMoreElements();)
{
mpStat = (MacroParseStat) e.nextElement();
StringBuffer stringbufferErrorMessage = new StringBuffer(new Integer(mpStat.getLineNum()).toString());
stringbufferErrorMessage.append(mpStat.getLineText());
stringbufferErrorMessage.append(mpStat.getStatMessage());
if (HPubTracingOn) { Ras.trace( className,"parseFailed",stringbufferErrorMessage.toString()); }
}
if (HPubTracingOn) { Ras.traceExit( className,"parseFailed"); }
}
// *************************************************************************
public void parsePassed()
{ // What we expected, so only trace that we go here
if (HPubTracingOn) { Ras.traceEntry( className,"parsePassed"); }
if (HPubTracingOn) { Ras.traceExit( className,"parsePassed"); }
}
// *************************************************************************
public synchronized void macroMessageEvent(MacroMessageEvent mmEv)
{ // A HOD Macro message event was fired for this macro.
// If there was a message associated with a macro screen (the only way
// to do this in this release is for the user to hand edit the macro file)
// then store it here, in this way another program can query about what
// screen the bean ended at.
if (HPubTracingOn) { Ras.traceEntry( className,"macroMessageEvent"); }
hPubMacroMessage = mmEv.getMessage();
if (HPubTracingOn) { Ras.traceExit( className,"macroMessageEvent"); }
}
// *************************************************************************
public void traceEvent(TraceEvent tEv)
{ // A HOD trace event was fired
// If tracing is on, or the trace event was a HOD exception, then
// pass this on to the HostPublisher subsystem for tracing.
int intMessageType;
intMessageType = tEv.getMsgType();
if ( (HPubTracingOn)
||(intMessageType == TraceEvent.LOGEXCEPTION)
)
{
if (oConn != null)
{
oConn.traceEvent(tEv);
}
}
}
// *************************************************************************
public synchronized void macroTraceEvent(MacroTraceEvent mtEv)
{ // A HOD trace event was fired for this macro
// If tracing is on, then pass this on to the HostPublisher subsystem
// for tracing.
if (HPubTracingOn)
{
Ras.trace(className, "macroTraceEvent", mtEv.getData());
}
}
// *************************************************************************
/**
* Public method used by HOD9.0 to inform the code executing a macro
* that a Macro Tracer action has been executed by the macro engine.
* This method saves the trace entry to the HP trace file only if User Macro Tracing
* or Support Tracing was selected.
*
* @param MacroTracerEvent
**/
public void macroTracerEvent(MacroTracerEvent mtEv)
{ // A HOD trace event was fired
// If tracing is on, or the trace event was a HOD exception, then
// pass this on to the HostPublisher subsystem for tracing.
if (oConn != null)
{
oConn.macroTracerEvent(mtEv);
}
}
// ****************************************************************************
public void macroErrorEvent(MacroErrorEvent oMacroErrorEvent)
{ // A HOD error event was fired for this macro
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
if (HPubTracingOn) { Ras.traceEntry( className,"macroErrorEvent"); }
// Prepend message string with notice that this was a macroerrorevent from HOD
ResourceBundle res = ResourceBundle.getBundle("com.ibm.HostPublisher.IntegrationObject.HPub_Resources",
Locale.getDefault());
StringBuffer errorEventMessage = new StringBuffer(res.getString("HOD_MACRO_ERROR_EVENT"));
// HOD is not translating this particular message for this release... do it for them
if ((oMacroErrorEvent.getMessageID() == Macro.EID_M_CONNECTION_DOWN))
errorEventMessage.append(res.getString("HOD_MACRO_ERROR_EVENT_CONNECTION_DOWN"));
else
errorEventMessage.append(oMacroErrorEvent.getMessage());
// Most of the error reporting will be done when the subsequent
// MacroStateEvent.STATE_PLAY_ERROR is received. But log the
// Error Event Message now.
if (HPubTracingOn) { Ras.trace( className, "macroErrorEvent: ", errorEventMessage.toString()); }
oErrorsToLog.stringToLog(errorEventMessage.toString());
oErrorsToLog.log(Ras.TYPE_ERROR, stringBeanName, className );
stringHODMacroError = new String("HOD_Macro_Error_1");
if (HPubTracingOn) { Ras.traceExit( className,"macroErrorEvent"); }
}
// ****************************************************************************
public void execute(MacroCustomActionEvent oMacroCustomActionEvent)
{//A HOD custom event was fired
if (HPubTracingOn) { Ras.traceEntry( className,"macroCustomActionEvent"); }
customlistener.setHodConn(oConn);
customlistener.execute(oMacroCustomActionEvent);
customlistener.releaseHodConn();
if (HPubTracingOn) { Ras.traceExit( className,"macroCustomActionEvent"); }
}
// ****************************************************************************
public void halt(MacroCustomActionEvent oMacroCustomActionEvent)
{//A HOD custom event gets halted
customlistener.setHodConn(oConn);
customlistener.halt(oMacroCustomActionEvent);
customlistener.releaseHodConn();
}
// ****************************************************************************
public void macroPromptEvent(MacroPromptEvent oMacroPromptEvent)
{ // A HOD Macro prompt event was fired for this macro
MacroPrompts oMacroPrompts;
HAOVariable haovWorkOnThis;
if (HPubTracingOn) { Ras.traceEntry( className,"macroPromptEvent"); }
// Set the all the prompt values that the IntegrationObject knows of.
// Get the HOD macro prompt object
oMacroPrompts = oMacroPromptEvent.getPrompts();
synchronized (this)
{ for (int i=0; i < vHAOVariables.size(); i++)
{ haovWorkOnThis = (HAOVariable) vHAOVariables.elementAt(i);
// Populate the object with the prompt values that were given to the bean
// via the "set" methods.
if (haovWorkOnThis.booleanInputVariable == true)
{ if ( ( (haovWorkOnThis.stringValue != null)
&&(haovWorkOnThis.stringValue.length() > 0)
)
||( (oMacroPrompts.getPromptDefault(haovWorkOnThis.stringPromptName) != null)
&&(oMacroPrompts.getPromptDefault(haovWorkOnThis.stringPromptName).length() > 0)
)
)
{ // If the object has a prompt value (usually obtain via the beans "set" methods),
// Or, if the object has not be given a prompt value but there has been
// defined a default value,
// then set it in the HOD Prompt object with
// the prompt name that was given by the user (using the Host Access GUI).
if (HPubTracingOn)
{ Ras.trace( className,"macroPromptEvent","Setting the following Prompt Name and Value",
haovWorkOnThis.stringPromptName, haovWorkOnThis.stringValue);
}
oMacroPrompts.setPromptValue(haovWorkOnThis.stringPromptName,haovWorkOnThis.stringValue);
}
else
{ // If the prompt value can not be set, and there is no default,
// then find the HOD prompt name for this object and set the prompt action to skip.
MacroActionPrompt oMacroActionPrompt = null;
String stringThisPromptName = new String(haovWorkOnThis.stringPromptName);
int intNumberOfPrompts = oMacroPrompts.size();
for (int j=0; j < intNumberOfPrompts; j++)
{ oMacroActionPrompt = oMacroPrompts.get(j);
if (stringThisPromptName.equals(oMacroActionPrompt.getName()))
{ oMacroActionPrompt.setSkip(true);
if (HPubTracingOn)
{ Ras.trace( className,"macroPromptEvent",
"MacroActionPrompt.setSkip called on the following Prompt Name",
haovWorkOnThis.stringPromptName);
}
break;
}
oMacroActionPrompt = null; // quick garbage collect
}
}
}
}
}
try
{ oMacroPromptEvent.setPrompts(oMacroPrompts);
}
catch (MacroException oException)
{ // Trace and Log Error
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
oErrorsToLog.handleException(oException, oHttpServletRequest, stringBeanName,
className, "macroPromptEvent", "HOD_Macro_Error_1", HPubTracingOn);
}
if (HPubTracingOn) { Ras.traceExit( className,"macroPromptEvent"); }
}
// ****************************************************************************
public void macroExtractEvent(MacroExtractEvent oMacroExtractEvent)
{ // a HOD macroExtractEvent was fired for this macro
HAOVariable haovWorkOnThis;
if (HPubTracingOn) { Ras.traceEntry( className,"macroExtractEvent"); }
// extract the data (VT,3270, 5250 datastream/emulator) that was associated with this extract
String stringExtractNameForThisEvent = oMacroExtractEvent.getExtractName();
String data [] = oMacroExtractEvent.getData();
if (HPubTracingOn)
{
Ras.trace( className,"macroExtractEvent","Extract Name: ", stringExtractNameForThisEvent);
for (int j=0; j < data.length; j++)
{
Ras.trace(className, "macroExtractEvent", "data extracted: ", data[j]);
}
}
// Go through list of objects, for each variable
// whose extract name matches stringExtractName, extract
// the correct fields for that object
synchronized (this)
{ for (int i = 0; i < vHAOVariables.size(); i++)
{ haovWorkOnThis = (HAOVariable) vHAOVariables.elementAt(i);
if ( haovWorkOnThis.stringExtractName.equals(stringExtractNameForThisEvent) == true)
{ pullVariableValueFromExtractData( haovWorkOnThis, data);
}
}
}
if (HPubTracingOn) { Ras.traceExit( className,"macroExtractEvent"); }
return;
}
// ****************************************************************************
public void pullVariableValueFromExtractData( HAOVariable haovTarget, String [] stringarrayExtractData)
{
// To make life easy
// X is horizontal, Y is Vertical
int intX = haovTarget.intXLocation; // location relative to the extracted data
int intDX = haovTarget.intXDelta;
int intY = haovTarget.intYLocation; // location relative to the extracted data
int intDY = haovTarget.intYDelta;
// -----------------------------------------------------------------------
// Note: The actual x,y coordinates of the variable relative to the
// host screen are located in:
// haovTarget.intXScreenLocation
// and
// haovTarget.intYScreenLocation
// -----------------------------------------------------------------------
if (HPubTracingOn) { Ras.traceEntry( className,"pullVariableValueFromExtractData"); }
// Check parameters, if invalid log error and return
if ( (intDX == 0)
||(intDY == 0)
||(intX < 0 )
||(intY < 0 )
||(intY >= stringarrayExtractData.length)
||(intY + intDY > stringarrayExtractData.length)
)
{ // log and trace error
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
oErrorsToLog.handleMessage(oHttpServletRequest, stringBeanName, className,
"pullVariableValueFromExtractData", "HOD_Macro_Error_2", HPubTracingOn);
if (HPubTracingOn) { Ras.traceExit( className,"pullVariableValueFromExtractData"); }
return;
}
if (haovTarget.intVariableType == HAO_VARIABLE_SIMPLE)
{ // simple (non-table) extract/object
StringBuffer stringbufferHoldingValue;
// concatenate multiple extracts which have the same name
if (haovTarget.stringValue == null)
{ stringbufferHoldingValue = new StringBuffer("");
}
else
{ stringbufferHoldingValue = new StringBuffer(haovTarget.stringValue);
}
if (intDY == 1)
{ // This extract is contained in one row of data
String stringOutput = pullStringFromIndexes(stringarrayExtractData[intY], intX, intDX,
haovTarget.intVariableType );
stringbufferHoldingValue.append(stringOutput);
}
else
{ for (int j = 0; j < intDY; j++)
{ // This extract spans multiple rows of data.
String stringOutput = pullStringFromIndexes(stringarrayExtractData[intY+j], intX, intDX,
haovTarget.intVariableType );
stringbufferHoldingValue.append(stringOutput);
}
}
if (stringbufferHoldingValue.toString() != null)
{ // store value in object
haovTarget.stringValue = new String( stringbufferHoldingValue.toString() );
}
if (HPubTracingOn)
{ Ras.trace( className,"pullVariableValueFromExtractData",
"Simple Variable Value Extracted: ", haovTarget.stringValue);
}
}
else
{ // vector (table) extract/object
for (int j = 0; j < intDY; j++)
{ // Go through each row and get this columns worth of data
String stringOutput = pullStringFromIndexes(stringarrayExtractData[intY+j], intX, intDX,
haovTarget.intVariableType );
if (HPubTracingOn)
{ Integer integerX = new Integer(j);
Ras.trace( className,"pullVariableValueFromExtractData ", integerX.toString(),
stringOutput);
}
// One object holds the entire column of data
haovTarget.oMultiValues.addElement(new String(stringOutput));
}
}
if (HPubTracingOn) { Ras.traceExit( className,"pullVariableValueFromExtractData"); }
}
// ****************************************************************************
public String pullStringFromIndexes( String stringInput, int intX, int intDX, int intVariableType)
{ // stringInput - string from which to acquire the substring.
// intX - starting index of the substring
// intDX - length of the substring
// intVariableType - if substring is a Simple object (non-table) or Vector (table)
// output - resulting substring
// This routine would not be needed, except for the case of the simple object
// that has DBCS characters, as described below
int intCount;
int intExtractStart;
int intExtractLength;
int intInputLength;
if (HPubTracingOn) { Ras.traceEntry( className,"pullStringFromIndexes"); }
if (booleanDBCSCodePageInUse)
{
// Screen Coordinates, and not Extract Coordinates are given for DBCS and Simple Variables
if (HPubTracingOn)
{ Ras.trace(className,"pullStringFromIndexes", "DBCS Code Page In Use detected");
}
intInputLength = stringInput.length();
// find where X starts inside of stringInput
intCount = 0;
for (intExtractStart=0; intExtractStart < intInputLength; intExtractStart++)
{ if (intCount >= intX) break;
if ( IsDBCSChar(stringInput.charAt(intExtractStart)) )
{ // DBCS characters take up two columns, but only one extracted character element
Ras.trace(className,"pullStringFromIndexes", "Extract Start - DBCS Character found");
intCount+=2;
}
else
{ intCount ++;
}
}
// Find the length of the desired extract
intCount = 0;
for (intExtractLength = 0; intExtractLength < intInputLength - intExtractStart; intExtractLength++)
{ if (intCount >= intDX) break;
if ( IsDBCSChar(stringInput.charAt(intExtractStart+intExtractLength)) )
{ // DBCS characters take up two columns, but only one extracted character element
Ras.trace(className,"pullStringFromIndexes", "Extract Length - DBCS Character found");
intCount+=2;
}
else
{ intCount ++;
}
}
}
else
{ // For single byte and table variables, the coordinates given in the extract match
// the coordinates that were determined by the Host Access GUI.
intExtractStart = intX;
intExtractLength = intDX;
}
if (HPubTracingOn)
{ Integer integerTemp = new Integer(intExtractStart);
Ras.trace(className,"pullStringFromIndexes", "extract start index: ", integerTemp);
integerTemp = new Integer(intExtractLength);
Ras.trace(className,"pullStringFromIndexes","extract length: ", integerTemp);
Ras.trace(className,"pullStringFromIndexes","returning following string: ",
stringInput.substring(intExtractStart, intExtractStart+intExtractLength));
}
if (HPubTracingOn) { Ras.traceExit( className,"pullStringFromIndexes"); }
// return the extracted string
return ( stringInput.substring(intExtractStart, intExtractStart+intExtractLength));
}
// ****************************************************************************
public boolean isDBCSCodePage(String codePage)
{ boolean booleanReturnCode = false;
if (HPubTracingOn) { Ras.traceEntry( className,"isDBCSCodePage"); }
booleanReturnCode = checkCodePages(DBCSCodePages, codePage);
if (HPubTracingOn) { Ras.traceExit( className,"isDBCSCodePage"); }
return booleanReturnCode;
}
// ****************************************************************************
private boolean checkCodePages(int[] codePageList, String codePage)
{ // check a list of code page numbers with a String that represents a number
boolean booleanReturnCode = false;;
if (HPubTracingOn) { Ras.traceEntry( className,"checkCodePages"); }
if ((codePageList == null) || (codePage == null))
{
if (HPubTracingOn) { Ras.traceExit( className,"checkCodePages"); }
return booleanReturnCode;
}
try
{
booleanReturnCode = checkCodePages(codePageList, Integer.valueOf(codePage).intValue());
if (HPubTracingOn) { Ras.traceExit( className,"checkCodePages"); }
return booleanReturnCode;
}
catch (NumberFormatException e)
{
// If a number format exception is caught then our value can not match any of the predefined values
// so return false.
if (HPubTracingOn) { Ras.traceExit( className,"checkCodePages"); }
return booleanReturnCode;
}
}
// ****************************************************************************
private boolean checkCodePages(int[] codePageList, int codePage)
{ // check a list of code page numbers with a code page number
boolean booleanReturnCode = false;
if (HPubTracingOn) { Ras.traceEntry( className,"checkCodePages"); }
for (int i=0; i < codePageList.length; i++)
{ if (codePageList[i] == codePage)
{ booleanReturnCode = true;
if (HPubTracingOn) { Ras.traceExit( className,"checkCodePages"); }
return booleanReturnCode;
}
}
if (HPubTracingOn) { Ras.traceExit( className,"checkCodePages"); }
return booleanReturnCode;
}
// ****************************************************************************
static public final int[] DBCSCodePages =
{ 930, // Japan Kana Ext
939, // Japan Eng Ext
933, // Korean
937, // Traditional Chinese
935, // Simpilified Chinese
942, // Japan ASCII
949, // Korea ASCII
950, // T-Chinese ASCII
948, // T-Chinese ASCII
964, // T-Chinese ASCII
1364, // Korean Euro
1371, // Taiwan Euro
1381, // Simplified Chinese
1388, // Simplified Chinese
1390, // Japan Katakana ( Extended Euro )
1399 // Japan Latin Euro (Host MBCS - Latin-Kanji)
};
// DBCS range table for UNICODE
private static final char[][] dbrange =
{
{'\u00B0', '\u00FF'}, // DB Latin 1 supplement
{'\u0100', '\u01FF'}, // DB Latin 1 Extended-A
{'\u02B0', '\u02E9'}, // DB Spacing Modifier
{'\u0370', '\u04FF'}, // DB Greek/Cyrillic
{'\u2000', '\u27BE'}, // DB Symbols
{'\u3000', '\u33FE'}, // CJK Misc
{'\u4E00', '\u9FFF'}, // CJK Ideographics
{'\uAC00', '\uD7A3'}, // Hanguel
{'\uE000', '\uF8FF'}, // User defined
{'\uF900', '\uFAFF'}, // CJK Compatibility
{'\uFE30', '\uFE4F'}, // CJK Compatibility
{'\uFE50', '\uFE6F'}, // Small form Variants
{'\uFF01', '\uFF5E'}, // full width ASCII
{'\uFFE0', '\uFFE6'}, // full width punctuation and currency signs
{'\u0000', '\u0000'} // end of table
};
// ****************************************************************************
public boolean IsDBCSChar(char charInput)
{ // check if input char (UNICODE character value) is within DBCS range
int i;
// if not DBCS session, always return false
boolean booleanDBCS = false;
// If single byte Korean Won, it should be treated as SBCS character
if (charInput == '\u20a9')
{ return booleanDBCS;
}
// If single byte Euro sign, it should be treated as SBCS chracter
if (charInput == '\u20ac')
{ return booleanDBCS;
}
// go thru the DBCS range table, and find if char is DBCS
for (i=0; dbrange[i][0] != '\u0000'; i++)
{ // if character is within DBCS range, return true
if ( (dbrange[i][0] <= charInput) && (dbrange[i][1] >= charInput) )
{ booleanDBCS = true;
break;
}
}
// these characters also take two columns for DBCS code pages
if ( (!booleanDBCS)
&&( (charInput == 0xa1) // inverted !
||(charInput == 0xa4) // currency Sign
||(charInput == 0xa7) // section sign
||(charInput == 0xa8) // diaeresis
||(charInput == 0xaa) // a with underscore
)
)
{ booleanDBCS = true;
}
return booleanDBCS;
}
// ****************************************************************************
public void macroStateEvent(MacroStateEvent oMacroStateEvent)
{ // a HOD macroStateEvent was fired for this macro
MacroScreen oMacroScreen;
if (HPubTracingOn) { Ras.traceEntry( className,"macroStateEvent"); }
switch (oMacroStateEvent.getState())
{ case MacroStateEvent.STATE_STOPPED:
// Macro is Stopped, which means it is ready to be played (which can also mean
// that the macro has finished playing)
if (HPubTracingOn) { Ras.trace( className,"macroStateEvent","STATE_STOPPED fired"); }
oMacroScreen = oMacroStateEvent.getMacroScreen();
if (oMacroScreen != null)
{ hPubScreenState = oMacroScreen.getName();
}
synchronized(this)
{ switch (intMacroState)
{ case MACRO_STATE_INSTANTIATED:
intMacroState = MACRO_STATE_READY_TO_PLAY;
if (HPubTracingOn) { Ras.trace( className,"macroStateEvent",
"perform notify at STATE_STOPPED(INSTANTIATED)"); }
// We are waiting in method "DoTheWork" to start playing
notify();
break;
case MACRO_STATE_PLAYING:
case MACRO_STATE_PARSE_ERROR:
intMacroState = MACRO_STATE_PLAY_FINISHED;
if (HPubTracingOn) { Ras.trace( className,"macroStateEvent","perform notify at STATE_STOPPED"); }
// We are waiting in method "DoTheWork" to be finished playing
notify();
break;
default:
break;
}
}
break;
case MacroStateEvent.STATE_PLAYING:
if (HPubTracingOn) { Ras.trace( className,"macroStateEvent","STATE_PLAYING fired"); }
oMacroScreen = oMacroStateEvent.getMacroScreen();
if (oMacroScreen != null)
{ hPubScreenState = oMacroScreen.getName();
}
break;
case MacroStateEvent.STATE_RECORDING:
case MacroStateEvent.STATE_PLAY_PAUSED:
case MacroStateEvent.STATE_RECORD_PAUSED:
// Since the macro is being run to completion, we don't expect to be in this state.
if (HPubTracingOn)
{ Ras.trace( className,"macroStateEvent", "STATE_RECORDING/PLAY_PAUSED/RECORD_PAUSE fired");
}
break;
case MacroStateEvent.STATE_EMPTY:
if (HPubTracingOn) { Ras.trace( className,"macroStateEvent","STATE_EMPTY fired"); }
// Trace and Log Error
HPubErrorsToLog oErrorsToLog2 = new HPubErrorsToLog();
oErrorsToLog2.handleMessage(oHttpServletRequest, stringBeanName, className,
"macroStateEvent", "HOD_Macro_Error_3", HPubTracingOn);
stringHODMacroError = new String("HOD_Macro_Error_3");
synchronized(this)
{ switch (intMacroState)
{ case MACRO_STATE_INSTANTIATED:
intMacroState = MACRO_STATE_READY_TO_PLAY;
if (HPubTracingOn) { Ras.trace( className,"macroStateEvent",
"perform notify at STATE_EMPTY(INSTANTIATED)"); }
// We are waiting in method "DoTheWork" to start playing
notify();
break;
case MACRO_STATE_PLAYING:
case MACRO_STATE_PARSE_ERROR:
// we should never get here (can't be playing an empty macro)
intMacroState = MACRO_STATE_PLAY_FINISHED;
if (HPubTracingOn) { Ras.trace( className,"macroStateEvent","perform notify at STATE_EMPTY"); }
// We are waiting in method "DoTheWork" to be finished playing
notify();
break;
}
}
break;
case MacroStateEvent.STATE_DISCONNECTED:
if (HPubTracingOn) { Ras.trace( className,"macroStateEvent","STATE_DISCONNECTED fired"); }
stringHODMacroError = new String("HOD_Macro_Error_1");
switch (intMacroState)
{ case MACRO_STATE_INSTANTIATED:
case MACRO_STATE_PLAYING:
case MACRO_STATE_PARSE_ERROR:
synchronized(this)
{ intMacroState = MACRO_STATE_PLAY_FINISHED;
if (HPubTracingOn) { Ras.trace( className,"macroStateEvent","perform notify at STATE_DISCONNECTED"); }
notify();
}
break;
default:
break;
}
break;
case MacroStateEvent.STATE_PLAY_ERROR:
ECLErr oECLErr;
ECLSession oECLSession;
ECLPS oECLPS;
char[] caBufferForOneRow;
int intNumberOfRows;
int intNumberOfColumns;
int intReadCount;
StringBuffer stringbufferScreenToLog = new StringBuffer();
String stringScreenToLog;
String stringMacroLineInError;
int intECLErrMsgNumber;
String stringECLErrText;
HPubErrorsToLog oErrorsToLog = new HPubErrorsToLog();
// Log and Trace the information we know about the status of the bean and macro
// Add messages to the ErrorsToLog object and then log and trace them with
// the ErrorsToLog.log() method
ResourceBundle res = ResourceBundle.getBundle("com.ibm.HostPublisher.IntegrationObject.HPub_Resources",
Locale.getDefault());
if (HPubTracingOn) { Ras.trace( className,"macroStateEvent","STATE_PLAY_ERROR fired"); }
// get the name of the last screen this macro was on
oMacroScreen = oMacroStateEvent.getMacroScreen();
if (oMacroScreen != null)
{ hPubScreenState = oMacroScreen.getName();
}
// log/trace the bean name
if (res != null)
{ String stringTemp = res.getString("Bean_Name");
oErrorsToLog.concatAndAddStrings(stringTemp, stringBeanName);
}
// log/trace the http session information (if we can)
try {
oErrorsToLog.addHttpServletRequestInformation(oHttpServletRequest);
}
catch (Exception e)
{
}
// log/trace the name of the host machine
if (sessionHost.getHost() != null)
{ String stringTemp = new String(sessionHost.getHost());
oErrorsToLog.stringToLog(stringTemp);
}
if (sessionHost.getSessionType().equals(ECLSession.SESSION_TYPE_3270_STR))
{ // log/trace LU Name (only valid for 3270 sessions)
String stringTemp = null;
stringTemp = sessionHost.getLUName();
if (stringTemp != null)
{ if (stringTemp.length() > 0)
{
oErrorsToLog.stringToLog(stringTemp);
}
}
}
// log/trace the macro name
if (macroBean != null)
{ String stringTemp1 = new String(res.getString("Macro_Name"));
oErrorsToLog.concatAndAddStrings(stringTemp1, stringMacroName);
}
// log/trace the error message stored in HOD.
oECLErr = oMacroStateEvent.getECLErr();
if (oECLErr != null)
{
oErrorsToLog.stringToLog(oECLErr.GetMsgText());
}
// log/trace the name of the last screen this macro was on
if (hPubScreenState != null)
{ if (res != null)
{ String stringTemp = new String(res.getString("Last_Screen_Name"));
oErrorsToLog.concatAndAddStrings(stringTemp, hPubScreenState);
}
}
else
{ if (res != null)
{ String stringTemp1 = new String(res.getString("Last_Screen_Name"));
String stringTemp2 = new String(res.getString("Null_Returned"));
oErrorsToLog.concatAndAddStrings(stringTemp1, stringTemp2);
}
}
// log/trace the contents of the current(last) screen that we are on.
oECLSession = sessionHost.getECLSession();
if (oECLSession != null)
{ oECLPS = oECLSession.GetPS();
if (oECLPS != null)
{ intNumberOfRows = oECLPS.GetSizeRows();
intNumberOfColumns = oECLPS.GetSizeCols();
caBufferForOneRow = new char[intNumberOfColumns + 1];
stringbufferScreenToLog.append(res.getString("Screen_Dump"));
stringbufferScreenToLog.append("\n");
// Append horizontal rule
for (int intI = 1; intI <= intNumberOfColumns + 2; intI++)
{ stringbufferScreenToLog.append("-");
}
stringbufferScreenToLog.append("\n");
// Append one row at a time, adding demarcating '|' characters at the
// beginning and the end of each row.
for (int intCurrentRow = 1; intCurrentRow <= intNumberOfRows; intCurrentRow++)
{ try
{ intReadCount = oECLPS.GetString(caBufferForOneRow, intNumberOfColumns + 1,
intCurrentRow, 1, intNumberOfColumns);
// Replace null character with demarcation character.
caBufferForOneRow[intReadCount] = '|';
stringbufferScreenToLog.append("|" + new String(caBufferForOneRow) + "\n");
}
catch (ECLErr oException)
{ // If we get an exception while trying to print the error
// information, then log the fact we got an exception, but don't
// worry about the details of the exception
String stringTemp = res.getString("ECLPS_Error_1");
oErrorsToLog.stringToLog(stringTemp);
}
}
// Append horizontal rule
for (int intI = 1; intI <= intNumberOfColumns + 2; intI++)
{ stringbufferScreenToLog.append("-");
}
stringbufferScreenToLog.append("\n");
ECLOIA oECLOIA = oECLSession.GetOIA();
stringbufferScreenToLog.append(res.getString("OIA_Input_Inhibited_Status") + " 0x"
+ Integer.toHexString(oECLOIA.InputInhibited()) + " "
+ convertOIAInputInhibitedStatus(oECLOIA.InputInhibited()) + "\n");
stringbufferScreenToLog.append(res.getString("OIA_Status_Flags") + " 0x"
+ Integer.toHexString(oECLOIA.GetStatusFlags()) + "\n");
stringbufferScreenToLog.append( res.getString("Comm_Status") + " 0x"
+ Integer.toHexString(sessionHost.getCommStatus()) + " "
+ convertCommStatus(sessionHost.getCommStatus()) + "\n");
stringScreenToLog = new String(stringbufferScreenToLog);
oErrorsToLog.stringToLog(stringScreenToLog);
}
}
oErrorsToLog.log(Ras.TYPE_ERROR, stringBeanName, className );
stringHODMacroError = new String("HOD_Macro_Error_1");
// If we will be passing the connection to the ZIETrans entry servlet
// for processing, then insure that we do not return the connection
// to the pool and we save it in the HTTP session object.
if ((getHPubSaveConnOnError() == true) &&
(isTransformConn() == true))
{
hPubEndType = BEAN_END_TO_CONNECTION;
if (oHttpServletRequest != null)
oHttpServletRequest.setAttribute(CommonConstants.HATS_EVENT, CommonConstants._ERROREVENT);
}
else
hPubEndType = BEAN_END_TO_POOL;
switch (intMacroState)
{ case MACRO_STATE_INSTANTIATED:
case MACRO_STATE_PLAYING:
case MACRO_STATE_PARSE_ERROR:
synchronized(this)
{ intMacroState = MACRO_STATE_PLAY_FINISHED;
if (HPubTracingOn)
{ Ras.trace( className,"macroStateEvent","perform notify at STATE_PLAY_ERROR");
}
notify();
}
break;
default:
break;
}
break;
default:
if (HPubTracingOn) { Ras.trace( className,"macroStateEvent","Unknown macro state fired"); }
break;
}
if (HPubTracingOn) { Ras.traceExit( className,"macroStateEvent"); }
}
// ****************************************************************************
public String convertCommStatus(int intCommStatus)
{
// convert communication status value to a string.
if (intCommStatus == Session.CONNECTION_ACTIVE)
return "CONNECTION_ACTIVE";
else if (intCommStatus == Session.CONNECTION_INACTIVE)
return "CONNECTION_INACTIVE";
else if (intCommStatus == Session.CONNECTION_INIT)
return "CONNECTION_INIT";
else if (intCommStatus == Session.CONNECTION_PND_INACTIVE)
return "CONNECTION_PND_INACTIVE";
else if (intCommStatus == Session.CONNECTION_PND_ACTIVE)
return "CONNECTION_PND_ACTIVE";
else if (intCommStatus == Session.CONNECTION_READY)
return "CONNECTION_READY";
else if (intCommStatus == Session.CONNECTION_DEVICE_NAME_READY)
return "CONNECTION_DEVICE_NAME_READY";
else
return Integer.toString(intCommStatus);
}
// ****************************************************************************
public String convertOIAInputInhibitedStatus(int intOIAInputInhibitedStatus)
{ // convert OIA Input Inhibited Status to a string
if (intOIAInputInhibitedStatus == com.ibm.eNetwork.ECL.ECLOIA.INHIBIT_NOTINHIBITED)
return "INHIBIT_NOTINHIBITED";
else if (intOIAInputInhibitedStatus == com.ibm.eNetwork.ECL.ECLOIA.INHIBIT_SYSTEMWAIT)
return "INHIBIT_SYSTEMWAIT";
else if (intOIAInputInhibitedStatus == com.ibm.eNetwork.ECL.ECLOIA.INHIBIT_COMMCHECK)
return "INHIBIT_COMMCHECK";
else if (intOIAInputInhibitedStatus == com.ibm.eNetwork.ECL.ECLOIA.INHIBIT_PROGCHECK)
return "INHIBIT_PROGCHECK";
else if (intOIAInputInhibitedStatus == com.ibm.eNetwork.ECL.ECLOIA.INHIBIT_MACHCHECK)
return "INHIBIT_MACHCHECK";
else if (intOIAInputInhibitedStatus == com.ibm.eNetwork.ECL.ECLOIA.INHIBIT_OTHERINHIBIT)
return "INHIBIT_OTHERINHIBIT";
else
return Integer.toString(intOIAInputInhibitedStatus);
}
// begin add for HPubExtractFieldAttributes
public String extendedxml = "";
public String getExtendedxml() {return extendedxml;}
// ADDED FOR XML TABLE
/**
* Callback for HOD Custom screen recognition.
* This tag must be added to the screen in the macro for which the attributes are to be retrieved:
* <customreco id="HPubExtractFieldAttributes|" optional="false" invertmatch="false" />
* It must be the last tag in the screen description so that the screen matches the other
* descriptors.
* When the macro is played, this code will be called when the screen matches the other
* descriptors. The attributes are gathered and saved as XML data in extendedxml. The data is retrieved by
* calling getExtendedxml()
*
* Always return true for customreco ids you have added ( including this sample ).
* Returning false would mean that the screen is not recognized.
*/
public boolean DoReco(ECLCustomRecoEvent e) //Custom Version
{
String descString = e.getID();
ECLPS ps = e.GetPS();
ECLScreenDesc screenDesc = e.GetScreenDesc();
int pos = -1;
String compareRegionOrValue;
String separator = "|";
pos = descString.indexOf(separator);
compareRegionOrValue = descString.substring(0,pos);
// Parse descString. Only handle "HPubExtractFieldAttributes" here.
// Super class with handle other CustomRecoEvents used in advanced
// screen recognition and fixed iteration looping.
if (compareRegionOrValue.equalsIgnoreCase("HPubExtractFieldAttributes"))
{
// call method to build XML file
extractFieldData( ps, screenDesc.GetName() );
// Always return true. Returning false would mean the screen is not
// recognized.
return true;
}
// not the extended attribute tag - return true
else
{
return super.DoReco(e);
}
} // end DoReco()
// ADDED FOR XML TABLE
/**
*
* Method to extract field data and build XML table which can be retrieved by JSP.
* This method may be modified to extract only specific data for specific fields.
* @param ECLPS - Presentation Space - includes characters and attributes sent from host
* @param screenName - not known to ECL Session ( may use "" )
**/
void extractFieldData( ECLPS ps, String screenName )
{
Object colortablebackground[] = {"Black","Blue","Green","Cyan","Red","Magenta","Yellow","White"};
Object colortableforeground[] = {"Black","Blue","Green","Cyan","Red","Magenta","WhiteHI","White",
"Gray","LightBlue","LightGreen","LightCyan","LightRed","LightMagenta","Yellow"};
int index;
String astr = ""; //Attribute String
ECLFieldList fields = null; // collection of information about fields
try
{
// get information for all planes
int planes = com.ibm.eNetwork.ECL.ECLPS.TEXT_PLANE |
com.ibm.eNetwork.ECL.ECLPS.FIELD_PLANE |
com.ibm.eNetwork.ECL.ECLPS.COLOR_PLANE |
com.ibm.eNetwork.ECL.ECLPS.EXFIELD_PLANE;
fields = ps.GetFieldList(planes);
}
catch (Exception e1)
{
System.out.println("Exception in DoReco calling ps.GetFieldList()");
fields = null;
}
// if fields is null, nothing to examine - bail out. xml file will be empty
if (fields == null)
{
System.out.println("DoReco - fields is null - cannot build xml");
return;
}
astr += "<Screen>\n";
astr += "<ScreenID>" + screenName + "</ScreenID>\n";
for(int i=0; i < fields.size(); i++)
{
ECLField field = null;
field = (ECLField) fields.elementAt(i);
if (field != null)
{
astr += "<Field>\n";
astr += "<FieldNumber>" + i + "</FieldNumber>\n";
astr += "<StartRow>" + field.GetStartRow() + "</StartRow>\n";
astr += "<StartColumn>" + field.GetStartCol() + "</StartColumn>\n";
astr += "<EndRow>" + field.GetEndRow() + "</EndRow>\n";
astr += "<EndColumn>" + field.GetEndCol() + "</EndColumn>\n";
astr += "<StartLinear>" + field.GetStart() + "</StartLinear>\n";
astr += "<EndLinear>" + field.GetEnd() + "</EndLinear>\n";
astr += "<Length>" + field.GetLength() + "</Length>\n";
if (field.IsProtected()) {
astr += "<Protected>true</Protected>\n";
} else {
astr += "<Protected>false</Protected>\n";
}
char buf1[] = new char[1000];
int length;
try {
length = field.GetString(buf1,1000);
} catch (Exception e3)
{
System.out.println("DoReco: Error calling ps.field.GetString()");
length = 0;
}
String textstr = new String(buf1);
astr += "<Text>" + textstr + "</Text>\n";
try {
length = field.GetScreen(buf1,1000,com.ibm.eNetwork.ECL.ECLPS.COLOR_PLANE);
} catch (Exception e4)
{
System.out.println("DoReco: Error calling ps.field.GetScreen()");
length = 0;
}
String foregroundString = "";
String backgroundString = "";
if (length > 0) length = 1; //Just get first color
for (int j=0; j<length; j++)
{
int compareintmask = 15;
int compareint;
compareint = buf1[j];
index = compareint & compareintmask;
foregroundString += colortableforeground[index]; // + ",";
index = (compareint >> 4);
index = index & 7;
backgroundString += colortablebackground[index]; // + ",";
}
astr += "<ForegroundColor>" + foregroundString + "</ForegroundColor>\n";
astr += "<BackgroundColor>" + backgroundString + "</BackgroundColor>\n";
if (field.IsHighIntensity()) {
astr += "<HighIntensity>true</HighIntensity>\n";
} else {
astr += "<HighIntensity>false</HighIntensity>\n";
}
if (field.IsDisplay()) {
astr += "<Displayable>true</Displayable>\n";
} else {
astr += "<Displayable>false</Displayable>\n";
}
if (field.IsModified()) {
astr += "<FieldModified>true</FieldModified>";
} else {
astr += "<FieldModified>false</FieldModified>";
}
astr += "</Field>\n";
}
}
astr += "</Screen>\n";
extendedxml = astr;
}
// end add for HPubExtractFieldAttributes
} // end class