//*****************************************************************************
//*                                                                           *
//* "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 com.ibm.bpe.api.*;
import com.ibm.task.api.*;
import commonj.sdo.DataObject;
import commonj.sdo.Property;
import commonj.sdo.Type;
import java.util.*;
 
 
public class MyTrace {
	
 

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( "   >  Threshold: "    + q.getThreshold() );
}

}