/**
* Initializes this object.
*
* @param key Property-key to use for locating initialization properties.
* @param type Property-type to use for locating initialization properties.
* @exception ProcessingException when initialization fails
*/
public void initialize(String key, String type) throws ProcessingException {
super.initialize(key, type);
StringBuffer errorBuf = new StringBuffer();
// serverName = getRequiredProperty(SERVER_NAME_PROP, errorBuf);
headerLocation = getPropertyValue(NF_HEADER_LOCATION_PROP);
isAsyncLocation = getPropertyValue(IS_ASYNCHRONOUS_LOCATION_PROP);
orbAgentAddr = getPropertyValue(ORB_AGENT_ADDR_PROP);
orbAgentPort = getPropertyValue(ORB_AGENT_PORT_PROP);
orbAgentAddrLocation = getPropertyValue(ORB_AGENT_ADDR_PROP_LOCATION);
orbAgentPortLocation = getPropertyValue(ORB_AGENT_PORT_PROP_LOCATION);
if (!StringUtils.hasValue(isAsyncLocation)) {
try {
isAsync =
StringUtils.getBoolean(
(String) getRequiredPropertyValue(DEFAULT_IS_ASYNCHRONOUS_PROP, errorBuf));
} catch (FrameworkException fe) {
errorBuf.append(
"No value is specified for either "
+ IS_ASYNCHRONOUS_LOCATION_PROP
+ "or"
+ DEFAULT_IS_ASYNCHRONOUS_PROP
+ ". One of the values should be present"
+ fe.getMessage());
}
}
if (!StringUtils.hasValue(headerLocation)) {
try {
header = getRequiredPropertyValue(DEFAULT_HEADER_PROP, errorBuf);
} catch (Exception e) {
errorBuf.append(
"No value is specified for "
+ NF_HEADER_LOCATION_PROP
+ "or"
+ DEFAULT_HEADER_PROP
+ ". One of the values should be present"
+ e.getMessage());
}
}
if (errorBuf.length() > 0) throw new ProcessingException(errorBuf.toString());
}
/////// for testing
public static void main(String[] args) {
if (args.length != 4) {
System.out.println("usage: java RTFGenerator dtabaseurl dbuser password xmlfile");
return;
}
RTFGenerator rt = new RTFGenerator();
try {
DBInterface.initialize(args[0], args[1], args[2]);
} catch (Exception exp) {
String e = exp.toString();
e = exp.getMessage();
e = "";
}
try {
rt.initialize("BS_ORDER", "RTF_GENERATOR");
} catch (Exception exp) {
exp.printStackTrace();
}
try {
String xmlmessage = FileUtils.readFile(args[3]);
rt.execute(null, xmlmessage);
} catch (Exception exp) {
exp.printStackTrace();
}
}
/**
* This method is called from driver. It does all processing to generate RTF document.
*
* @param context - MessageProcessorContext.
* @param type - input - this contains XML message that needs to e converted to RTF document.
* @return NVPair[] - this array contains only one instance of NVPair. name - value of
* NEXT_PROCESSOR_NAME; value - generated RTF document.
* @exception - MessageException, ProcessingException - messageException is thrown if parsing of
* XML fails ProcessingException is thrown for any other significant error.
*/
public NVPair[] execute(MessageProcessorContext context, Object input)
throws MessageException, ProcessingException {
Debug.log(this, Debug.BENCHMARK, "RTFGenerator: Starting conversion of XML to RTF document");
if (input == null) {
return null;
}
String xmlMessage = Converter.getString(input);
TokenDataSource tds = new XMLTokenDataSourceAdapter(xmlMessage);
String template = getRTFTemplate();
com.nightfire.framework.util.TokenReplacer tr =
new com.nightfire.framework.util.TokenReplacer(template);
tr.setTokenStartIndicator(startDelimiter);
tr.setTokenEndIndicator(endDelimiter);
tr.setAllDataOptional(true);
String result = "";
try {
result = tr.generate(tds);
} catch (FrameworkException exp) {
throw new ProcessingException(
"ERROR: RTFGenerator: Error in translating XML to RTF document");
}
Debug.log(this, Debug.BENCHMARK, "RTFGenerator: Done conversion of XML to RTF document");
// Generate NVPair to return
NVPair nvpair = new NVPair(nextProcessor, result);
NVPair array[] = new NVPair[] {nvpair};
// for testing only
if (testing) {
try {
FileUtils.writeFile("e:\\OP.rtf", result);
} catch (Exception exp) {
exp.printStackTrace();
}
}
return array;
}
public static void main(String[] args) {
Debug.enableAll();
String HEADER =
"<HEADER>"
+ "<REQUEST value=\"LSR_ORDER\"/>"
+ "<SUB_REQUEST value=\"loop\"/>"
+ "<SUPPLIER value=\"VZE\"/>"
+ "</HEADER>";
RequestHandlerClient sr = null;
try {
String xml = FileUtils.readFile(args[0]);
MessageProcessorContext ctx = new MessageProcessorContext();
ctx.set("NF_HEADER_LOCATION_PROP", HEADER);
sr = new RequestHandlerClient();
sr.serverName = "Nightfire.Router";
NVPair[] result = sr.process(ctx, new MessageObject((Object) xml));
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* If NF_HEADER_LOCATION_PROP exists in context use as the header to forward to Gateway. If
* IS_ASYNCHRONOUS_PROP exists in context then use that value to call either processAsync or
* processSync
*
* @param input MessageObject containing the value to be processed *
* @param mpcontext The context
* @return Optional NVPair containing a Destination name and a MessageObject, or null if none.
* @exception ProcessingException Thrown if processing fails.
* @exception MessageException Thrown if bad message.
*/
public NVPair[] process(MessageProcessorContext ctx, MessageObject input)
throws MessageException, ProcessingException {
if (input == null) return null;
try {
serverName = getRequiredProperty(ctx, input, SERVER_NAME_PROP);
} catch (MessageException me) {
throw new ProcessingException(me.getMessage());
}
if (StringUtils.hasValue(headerLocation)) {
try {
header = getString(headerLocation, ctx, input);
} catch (MessageException me) {
throw new ProcessingException(me.getMessage());
}
}
if (StringUtils.hasValue(isAsyncLocation)) {
try {
isAsync = StringUtils.getBoolean(getString(isAsyncLocation, ctx, input));
} catch (FrameworkException fe) {
throw new ProcessingException(
"Value of " + IS_ASYNCHRONOUS_LOCATION_PROP + " is not TRUE/FALSE. " + fe.getMessage());
}
}
// Fetch the alternate Orb Address, if one exists at the specified context location
if (StringUtils.hasValue(orbAgentAddrLocation)) {
try {
if (exists(orbAgentAddrLocation, ctx, input, true)) {
orbAgentAddr = getString(orbAgentAddrLocation, ctx, input);
if (Debug.isLevelEnabled(Debug.MSG_STATUS))
Debug.log(
Debug.MSG_STATUS,
"RequestHandlerClient:: alternate orb exists with orb agent address ["
+ orbAgentAddr
+ "]");
}
} catch (MessageException me) {
throw new ProcessingException(me.getMessage());
}
}
// Fetch the alternate Orb Port, if one exists at the specified context location
if (StringUtils.hasValue(orbAgentPortLocation)) {
try {
if (exists(orbAgentPortLocation, ctx, input, true)) {
orbAgentPort = getString(orbAgentPortLocation, ctx, input);
if (Debug.isLevelEnabled(Debug.MSG_STATUS))
Debug.log(
Debug.MSG_STATUS,
"RequestHandlerClient:: alternate orb exists with orb agent port ["
+ orbAgentPort
+ "]");
}
} catch (MessageException me) {
throw new ProcessingException(me.getMessage());
}
}
String msg = input.getString();
try {
try {
return (formatNVPair(makeClientCall(serverName, false, header, msg)));
} catch (Exception e) {
// Any of the following exceptions indicate that the failure might be due to
// a CORBA communications issue (stale object reference) that should be retried.
if ((e instanceof org.omg.CORBA.OBJECT_NOT_EXIST)
|| (e instanceof org.omg.CORBA.TRANSIENT)
|| (e instanceof org.omg.CORBA.COMM_FAILURE)
|| (e instanceof org.omg.CORBA.INV_OBJREF)
|| (e instanceof org.omg.CORBA.UNKNOWN)) {
Debug.warning(
"Caught the following CORBA communication error, so retrying:\n"
+ e.toString()
+ "\n"
+ Debug.getStackTrace(e));
return (formatNVPair(makeClientCall(serverName, true, header, msg)));
} else {
// It's not a communication exception indicating that retry is recommended,
// so just re-throw it.
throw e;
}
}
} catch (Exception e) {
if (e instanceof InvalidDataException) {
Debug.error(e.toString() + "\n" + Debug.getStackTrace(e));
throw new MessageException(((InvalidDataException) e).errorMessage);
} else {
Debug.error(e.toString() + "\n" + Debug.getStackTrace(e));
throw new ProcessingException(e.toString());
}
}
}