mytrace.java

来自「Java开的发文件管理系统,可以管理整个服务器的文件,并按要求进行处理!」· Java 代码 · 共 355 行

package com.ibm.gbsc.cte.sample;

//*****************************************************************************
//*                                                                           *
//* "This sample program is provided AS IS and may be used, executed, copied  *
//* and modified without royalty payment by customer                          *
//* (a) for its own instruction and study,                                    *
//* (b) in order to develop applications designed to run with an              *
//*     IBM WebSphere product, either for customer's own internal use or for  *
//*     redistribution by customer, as part of such an application, in        *
//*     customer's own products."                                             *
//*                                                                           *
//* Product 5655-FLW,                                                         *
//* (C) COPYRIGHT International Business Machines Corp., 2006                 *
//* All Rights Reserved * Licensed Materials - Property of IBM                *
//*                                                                           *
//*****************************************************************************
//*                                                                           *
//* DISCLAIMER                                                                *
//*                                                                           *
//* This material contains programming source code for your consideration.    *
//* These examples have not been thoroughly tested under all conditions.      *
//* IBM, therefore, cannot guarantee or imply reliability, serviceability,    *
//* or function of these programs.                                            *
//* ALL PROGRAMS CONTAINED HEREIN ARE PROVIDED TO YOU "AS IS", WITHOUT ANY    *
//* WARRANTIES (EXPRESS OR IMPLIED) OR SUPPORT WHATSOEVER, INCLUDING BUT      *
//* NOT LIMITED TO ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS       *
//* FOR A PARTICULAR PURPOSE.                                                 *
//*                                                                           *
//*****************************************************************************
import java.util.List;

import com.ibm.bpe.api.AIID;
import com.ibm.bpe.api.ActivityInstanceData;
import com.ibm.bpe.api.BusinessFlowManager;
import com.ibm.bpe.api.PIID;
import com.ibm.bpe.api.ProcessInstanceData;
import com.ibm.bpe.api.StoredQueryData;
import com.ibm.task.api.HumanTaskManager;
import com.ibm.task.api.TKIID;
import com.ibm.task.api.Task;
import commonj.sdo.DataObject;
import commonj.sdo.Property;
import commonj.sdo.Type;

public class MyTrace {

	public static void trace(String log) {
		System.out.println("\n" + log);
	}

	public static void trace(AIID aiid, String comment, BusinessFlowManager bfm)
			throws com.ibm.bpe.api.ProcessException {
		try {
			trace(bfm.getActivityInstance(aiid), comment);
		} catch (java.rmi.RemoteException xcpt) {
			System.out.println(xcpt);
			throw new com.ibm.bpe.api.ProcessException(null, xcpt);
		}
	}

	public static void trace(ActivityInstanceData a) {
		trace(a, null);
	}

	public static void trace(ActivityInstanceData a, String comment) {
		if (comment != null)
			System.out.println("\n > " + comment + ":  ");
		else
			System.out.println("\n > activity: ");

		System.out.println("  > AIID                 : " + a.getID());
		System.out.println("  > Process instance id  : "
				+ a.getProcessInstanceID());
		System.out.println("  > Process name         : "
				+ a.getProcessTemplateName());
		System.out.println("  > InputMessageTypeName : "
				+ a.getInputMessageTypeName());
		System.out.println("  > OutputMessageTypeName: "
				+ a.getOutputMessageTypeName());

		// System.out.println(" > Last modification : " +
		// a.getLastStateChangeTime().getTime());
		String state = null;
		if (a.getExecutionState() == ActivityInstanceData.STATE_INACTIVE) {
			state = "STATE_INACTIVE";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_READY) {
			state = "STATE_READY";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_RUNNING) {
			state = "STATE_RUNNING";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_SKIPPED) {
			state = "STATE_SKIPPED";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_FINISHED) {
			state = "STATE_FINISHED";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_FAILED) {
			state = "STATE_FAILED";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_TERMINATED) {
			state = "STATE_TERMINATED";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_CLAIMED) {
			state = "STATE_CLAIMED";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_TERMINATING) {
			state = "STATE_TERMINATING";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_FAILING) {
			state = "STATE_FAILING";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_WAITING) {
			state = "STATE_WAITING";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_EXPIRED) {
			state = "STATE_EXPIRED";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_STOPPED) {
			state = "STATE_STOPPED";
		} else if (a.getExecutionState() == ActivityInstanceData.STATE_PROCESSING_UNDO) {
			state = "STATE_PROCESSING_UNDO";
		} else {
			state = "UNKNOWN";
		}
		System.out.println("  > State                : " + state);
	}

	public static void trace(PIID piid, String comment, BusinessFlowManager bfm)
			throws com.ibm.bpe.api.ProcessException {
		try {
			trace(bfm.getProcessInstance(piid), comment);
		} catch (java.rmi.RemoteException xcpt) {
			System.out.println(xcpt);
			throw new com.ibm.bpe.api.ProcessException(null, xcpt);
		}
	}

	public static void trace(PIID piid, BusinessFlowManager bfm)
			throws com.ibm.bpe.api.ProcessException {
		trace(piid, null, bfm);
	}

	public static void trace(ProcessInstanceData p)
			throws com.ibm.bpe.api.ProcessException {
		trace(p, null);
	}

	public static void trace(ProcessInstanceData p, String comment) {
		if (comment != null)
			System.out.println("\n > " + comment + ":  ");
		else
			System.out.println("\n > process instance: ");
		System.out.println("   > name                 : " + p.getName());
		System.out.println("   > piid                 : " + p.getID());
		System.out.println("   > template name        : "
				+ p.getProcessTemplateName());
		System.out.println("   > display name         : " + p.getDisplayName());
		System.out.println("   > starter              : " + p.getStarter());
		System.out.println("   > InputMessageTypeName : "
				+ p.getInputMessageTypeName());
		System.out.println("   > OutputMessageTypeName: "
				+ p.getOutputMessageTypeName());
		String state = null;
		int executionState = p.getExecutionState();
		if (executionState == ProcessInstanceData.STATE_COMPENSATED) {
			state = "STATE_COMPENSATED";
		} else if (executionState == ProcessInstanceData.STATE_COMPENSATING) {
			state = "STATE_COMPENSATING";
		} else if (executionState == ProcessInstanceData.STATE_COMPENSATING) {
			state = "STATE_COMPENSATING";
		} else if (executionState == ProcessInstanceData.STATE_COMPENSATION_FAILED) {
			state = "STATE_COMPENSATION_FAILED";
		} else if (executionState == ProcessInstanceData.STATE_FAILED) {
			state = "STATE_FAILED";
		} else if (executionState == ProcessInstanceData.STATE_FAILING) {
			state = "STATE_FAILING";
		} else if (executionState == ProcessInstanceData.STATE_FINISHED) {
			state = "STATE_FINISHED";
		} else if (executionState == ProcessInstanceData.STATE_READY) {
			state = "STATE_READY";
		} else if (executionState == ProcessInstanceData.STATE_RUNNING) {
			state = "STATE_RUNNING";
		} else if (executionState == ProcessInstanceData.STATE_SUSPENDED) {
			state = "STATE_SUSPENDED";
		} else if (executionState == ProcessInstanceData.STATE_TERMINATED) {
			state = "STATE_TERMINATED";
		} else if (executionState == ProcessInstanceData.STATE_TERMINATING) {
			state = "STATE_TERMINATING";
		}
		System.out.println("   > state                : " + state);
		System.out.println("   > created              : "
				+ p.getCreationTime().getTime());
		System.out.println("   > started              : "
				+ p.getStartTime().getTime());

	}

	public static void trace(DataObject dataObject) {
		trace(dataObject, null);
	}

	public static void trace(DataObject dataObject, String comment) {
		if (comment != null)
			System.out.println("\n > " + comment + ": ");
		else
			System.out.println("\n > dataObject: ");

		// Retrieve the Type
		Type type = dataObject.getType();
		System.out.println("   > type URI   = " + type.getURI());
		System.out.println("   > type name  = " + type.getName());

		List properties = type.getProperties();
		for (int p = 0; p < properties.size(); p++) {
			Property property = (Property) properties.get(p);
			if (dataObject.isSet(p)) {
				if (property.isMany()) {
					List values = dataObject.getList(p);
					for (int v = 0, count = values.size(); v < count; v++) {
						traceValue(values.get(v), property);
					}
				} else {
					// For single-valued properties, trace the value
					traceValue(dataObject.get(p), property);
				}
			} else {
				// the property is considered to be not set
				String propertyName = property.getName();
				String typeName = property.getType().getName();

				System.out.println("   > prop name  = " + propertyName);
				System.out.println("   > prop type  = " + typeName);
				System.out.println("   > prop value = NOT SET");
			}
		}
	}

	private static void traceValue(Object value, Property property) {
		// Get the name and type of the property
		String propertyName = property.getName();
		String typeName = property.getType().getName();

		if (value != null && property.isContainment()) {
			// For containment properties, trace the value with traceDataObject
			System.out.println("   > prop name  = " + propertyName);
			System.out.println("   > prop type  = " + typeName);
			if (value instanceof DataObject) {
				trace((DataObject) value, "dataObject: " + typeName);
			} else {
				System.out.println("   NO DataObject INSTANCE");
			}
		} else {
			// For non-containment properties, just trace the value
			System.out.println("   > prop name  = " + propertyName);
			System.out.println("   > prop type  = " + typeName);
			System.out.println("   > prop value = " + value);
		}
	}

	public static void trace(TKIID tkiid, HumanTaskManager htm)
			throws com.ibm.task.api.TaskException {
		try {
			trace(htm.getTask(tkiid), null);
		} catch (java.rmi.RemoteException xcpt) {
			System.out.println(xcpt);
			throw new com.ibm.task.api.TaskException(null, xcpt);
		}
	}

	public static void trace(TKIID tkiid, String comment, HumanTaskManager htm)
			throws com.ibm.task.api.TaskException {
		try {
			trace(htm.getTask(tkiid), comment);
		} catch (java.rmi.RemoteException xcpt) {
			System.out.println(xcpt);
			throw new com.ibm.task.api.TaskException(null, xcpt);
		}
	}

	public static void trace(Task t) {
		trace(t, null);
	}

	public static void trace(Task t, String comment) {
		if (comment != null) {
			System.out.println("\n > " + comment);
		} else {
			System.out.println("\n > Task :");
		}
		System.out.println("  > TKIID                : " + t.getID());
		System.out.println("  > Name                 : " + t.getName());
		System.out.println("  > Namespace            : " + t.getNamespace());
		System.out.println("  > ApplicationDefaultID : "
				+ t.getApplicationDefaultsID());
		String kind = null;
		if (t.getKind() == Task.KIND_HUMAN) {
			kind = "KIND_HUMAN";
		} else if (t.getKind() == Task.KIND_WPC_STAFF_ACTIVITY) {
			kind = "KIND_WPC_STAFF_ACTIVITY";
		} else if (t.getKind() == Task.KIND_ORIGINATING) {
			kind = "KIND_ORIGINATING";
		} else if (t.getKind() == Task.KIND_PARTICIPATING) {
			kind = "KIND_PARTICIPATING";
		} else if (t.getKind() == Task.KIND_ADMINISTRATIVE) {
			kind = "KIND_ADMINISTRATIVE";
		} else {
			kind = "UNKNOWN";
		}
		System.out.println("  > Kind                 : " + kind);

		System.out.println("  > Activation time      : "
				+ t.getActivationTime().getTime());
		System.out.println("  > Last change time     : "
				+ t.getLastStateChangeTime().getTime());

		String state = null;
		if (t.getState() == Task.STATE_INACTIVE) {
			state = "STATE_INACTIVE";
		} else if (t.getState() == Task.STATE_READY) {
			state = "STATE_READY";
		} else if (t.getState() == Task.STATE_RUNNING) {
			state = "STATE_RUNNING";
		} else if (t.getState() == Task.STATE_FINISHED) {
			state = "STATE_FINISHED";
		} else if (t.getState() == Task.STATE_FAILED) {
			state = "STATE_FAILED";
		} else if (t.getState() == Task.STATE_TERMINATED) {
			state = "STATE_TERMINATED";
		} else if (t.getState() == Task.STATE_CLAIMED) {
			state = "STATE_CLAIMED";
		} else if (t.getState() == Task.STATE_EXPIRED) {
			state = "STATE_EXPIRED";
		} else if (t.getState() == Task.STATE_FORWARDED) {
			state = "STATE_FORWARDED";
		} else {
			state = "UNKNOWN";
		}
		System.out.println("  > State                : " + state);
		if (t.isSuspended()) {
			System.out.println("  > suspended            : " + "yes");
		}
		System.out.println("\n");
	}

	public static void trace(StoredQueryData q) {
		trace(q, null);
	}

	public static void trace(StoredQueryData q, String comment) {
		if (comment != null) {
			System.out.println("\n > " + comment);
		} else {
			System.out.println("\n > Stored Query :");
		}

		System.out.println("   >  Name: " + q.getName());
		System.out.println("   >  SelectClause: " + q.getSelectClause());
		System.out.println("   >  WhereClause: " + q.getWhereClause());
		System.out.println("   >  OrderClause: " + q.getOrderByClause());
		System.out.println("   >  Thershold: " + q.getThreshold());
	}

}