When viewing or scheduling a report, JReport Enterprise Server enables you to call your java application before or after the process.
In JReport Enterprise Server, the TaskListener interface is provided in
the package jet.server.api for receiving task events before or after running.
You can specify one java class to implement this interface for a task
event. When the event of this task occurs, corresponding methods in the
listener will be invoked. The interface contains two methods: beforeRun
and afterRun, enabling you to set your java application call before
or after the process of viewing a report or setting up a schedule. Your
applications will return true or false. For true, JReport Enterprise Server
will go on running; while for false, JReport Enterprise Server will stop there.
Below is an example to illustrate how to add TaskListener when setting up a schedule on a report.
- Develop your java class to implement the interface. In our example, we use TestTaskListener.java.
// This is an example to demonstrate how to implement user's own scripts
// before and after task running and how to get the information about a task.
import java.util.*;
import java.text.DateFormat;
import jet.server.api.TaskListener;
import jet.server.api.ServerInfo;
import jet.server.api.RptServerException;
import jet.cs.util.APIConst;
// Note: First step: save this file under a proper path,
// for example, c:\jrentserver\tasklistener, and edit the batch file
// %InstallRoot%\bin\JREntServer.bat by adding the path of the class
// file (c:\jrentserver\tasklistener) to the classpath.
// Second step: start JReport Enterprise Server and schedule
// a report. Check "Add TaskListener to be invoked", and input the class
// name, in this example, we input TestTaskListener, and then submit the task.
// The result will print in the command window before and after the task
// is run.
public class TestTaskListener implements TaskListener {
private String toVersion = "jet.server.schedule.jrtasks.UpdateRptTask";
private String toFileSystem = "jet.server.schedule.jrtasks.PublishToDiskTask";
private String toEmail = "jet.server.schedule.jrtasks.SendJRMailTask";
private String toPrinter = "jet.server.schedule.jrtasks.PrintRptTask";
// This method will be called automatically BEFORE a task is run,
// which means any scripts added into the method will automatically be executed.
public boolean beforeRun(ServerInfo serverInfo) {
System.out.println("------------- Before Task Running ----------");
try {
// "taskType" will store the task-type info got from TaskProperties.
// It can be used to determine what kind of task will start to run.
String taskType = (String)serverInfo.getTaskProperties().get(APIConst.TAG_TASK_CLASS);
if (taskType.equals(toVersion)) {
System.out.println("Task Type is: Publish to Versioning System.");
} else if (taskType.equals(toFileSystem)) {
System.out.println("Task Type is: Publish to File System.");
} else if (taskType.equals(toEmail)) {
System.out.println("Task Type is: Publish to Email.");
} else if (taskType.equals(toPrinter)) {
System.out.println("Task Type is: Publish to Printer.");
}
// "lType" will store the launch-type info got from TaskProperties.
// It can be use to determine in which launch type the task will be running.
String lType = (String)serverInfo.getTaskProperties().get(APIConst.TAG_LAUNCH_TYPE);
if (lType == null) {
System.out.println("Launch Type is: Immediately.");
} else if (lType.equals(String.valueOf(APIConst.AT_TIME))) {
System.out.println("Launch Type is: At time.");
} else if (lType.equals(String.valueOf(APIConst.PERIODICALLY))) {
System.out.println("Launch Type is: Repeatedly.");
}
System.out.println
("TaskID is: " + serverInfo.getTaskProperties().get(APIConst.TAG_TASK_ID));
System.out.println
("TaskSubmiter is: " + serverInfo.getTaskProperties().get(APIConst.TAG_UID));
System.out.println
("Report is: " + serverInfo.getTaskProperties().get(APIConst.TAG_REPORT));
System.out.println
("Catalog is: " + serverInfo.getTaskProperties().get(APIConst.TAG_CATALOG));
System.out.println
("Submit time is:" + serverInfo.getTaskProperties().get(APIConst.TAG_SUBMIT_TIME));
// Note: Some information will be created only when the task
// who owns them is running.
// ExeYear, ExeMonth, ExeDay, ExeHour, ExeMin, and ExeSec
// only exist when a periodical task is run.
if (lType != null && lType.equals(String.valueOf(APIConst.AT_TIME))) {
System.out.println
("ExeYear=" + (String) serverInfo.getTaskProperties().get(APIConst.TAG_EXE_YEAR));
System.out.println
("ExeMonth=" + (String) serverInfo.getTaskProperties().get(APIConst.TAG_EXE_MONTH));
System.out.println
("ExeDay=" + (String) serverInfo.getTaskProperties().get(APIConst.TAG_EXE_DAY));
System.out.println
("ExeHour=" + (String) serverInfo.getTaskProperties().get(APIConst.TAG_EXE_HOUR));
System.out.println
("ExeMin=" + (String) serverInfo.getTaskProperties().get(APIConst.TAG_EXE_MIN));
System.out.println
("ExeSec=" + (String) serverInfo.getTaskProperties().get(APIConst.TAG_EXE_SEC));
}
// TaskProperties can provide lots of other useful information,
// System.out.println(serverInfo.getTaskProperties());
// By using the script above, you can output all information stored in TaskProperties.
System.out.println("For more information, please check <TaskProperties>!\n");;
// getTaskProperties and serverInfo.getSchdproperties will throw a RptServerException,
// which must be caught.>
} catch (RptServerException e) {
System.out.println("RptServerException throws out!\n"
+ "Message in exception object:\n\t" + e.getMessage());
}
return true;
// if the return value is true, the task will start to run.
// if the return value is false, the task will not run.
}
// This method will be called automatically AFTER a task is accomplished.
public void afterRun(ServerInfo serverInfo) {
System.out.println("------------- After Task Running ----------");
try {
// CompleteTime is not stored in TaskProperties, but it can be obtained
// by calling this method.
String completeTime = DateFormat.getDateTimeInstance().format(new java.util.Date
(System.currentTimeMillis()));
System.out.println ("Completed Time=" + String.valueOf(completeTime));
System.out.println ("Engine Message =" + (String)
serverInfo.getTaskProperties().get(APIConst.TAG_ENG_MSG));
// isSuccessful only exists after a task is accomplished or terminated with an
// error, so it should be obtained only in afterRun()
String isSuccessful =
(String) serverInfo.getScheduleProperties().get(APIConst.TAG_IS_SUCCESSFUL);
if (isSuccessful == "false") {
// Task is terminated with errors,
// System.out.println
("Error Message =" +(String)serverInfo.getTaskProperties().get(APIConst.TAG_ERROR));
// Another alternative is using the script above to output error details.
System.out.println("Task terminated with some errors.
\nFor more information, please check <TAG_ERROR of TaskProperties>!");
} else {
System.out.println("Task accomplished successfully!\n");
}
} catch (RptServerException e) {
System.out.println("RptServerException throws out!\n"
+ "Message in exception object:\n\t" + e.getMessage());
}
}
}
|
- Compile TestTaskListener.java to generate the class file.
- Edit the batch file %InstallRoot%\bin\JREntServer.bat, which is used
to start the JREntServer. Suppose TestTaskListener is saved in
c:\jrentserver\tasklistener,
add the path of the class file (c:\jrentserver\tasklistener)
to the classpath in JREntServer.bat.
- Start JReport Enterprise Server and set up a schedule on a report. Check Add TaskListerner to be invoked, and input the class
name with its package, in this example, input TestTaskListener. Then submit the task.
- In this example, the class returns "
True".
Print out the task properties and schedule properties before and after running the task. So you will get task and schedule information in the command window before and after the task is run.
You can also define properties of your own and transmit them through ServerInfo. To do so, you use APIConst. TAG_USERDEFINED_PROPERTY_PREFIX as the prefix for the properties.
For example, if you want to transmit the properties host_name, host_ip and hosp_protocol, you need to insert the properties, before calling the method runTask, into the Properties named prop, as follows:
prop.put(APIConst. TAG_USERDEFINED_PROPERTY_PREFIX+"host_name", "host");
prop.put(APIConst. TAG_USERDEFINED_PROPERTY_PREFIX+"host_ip", "192.10.10.6");
prop.put(APIConst. TAG_USERDEFINED_PROPERTY_PREFIX+"host_protocol"+ "TCP/IP");
|
You can get the value of the properties listed above through the ServerInfo object, serverInfo, in the method beforeRun or afterRun of the TaskListener class. See the example below:
host_name=serverInfo.getTaskProperties().get(APIConst.TAG_USERDEFINED_PROPERTY_PREFIX+"host_name");
host_ip=serverInfo.getTaskProperties().get(APIConst.TAG_USERDEFINED_PROPERTY_PREFIX+"host_ip");
host_protocol=serverInfo.getTaskProperties().get(APIConst.TAG_USERDEFINED_PROPERTY_PREFIX+"host_protocol");
|
Note: All properties without the prefix, APIConst. TAG_USERDEFINED_PROPERTY_PREFIX, will be denied and discarded by JReport Enterprise Server.
