// ---------------------------------------------------------
// (c) Copyright IBM Corp. 1999  All rights reserved.
//
// This sample program is owned by International Business Machines
// Corporation or one of its subsidiaries ("IBM") and is copyrighted
// and licensed, not sold.
//
// You may copy, modify, and distribute this sample program in any
// form without payment to IBM,  for any purpose including developing,
// using, marketing or distributing programs that include or are
// derivative works of the sample program.
//
// The sample program is provided to you on an "AS IS" basis, without
// warranty of any kind.  IBM HEREBY  EXPRESSLY DISCLAIMS ALL WARRANTIES,
// EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
// Some jurisdictions do not allow for the exclusion or limitation of
// implied warranties, so the above limitations or exclusions may not
// apply to you.  IBM shall not be liable for any damages you suffer as
// a result of using, modifying or distributing the sample program or
// its derivatives.
//
// ---------------------------------------------------------
// This sample illustrates how to retrieve the workitems for a specific user.
//
// -- User is prompted for a MQWF user ID
// -- The workitems for that user are displayed
// -- The user can then decide to start a ready item
//
// To compile this on WindowsNT using MSVC++ 5.0,  type:
//    cl -MD sampwrkl.c fmcjdcom.lib fmcjdcbr.lib fmcjdcon.lib fmcjdrun.lib
// dsb 01-25-99
// ----------------------------------------------------------

#include <stdio.h>
#include "fmcjcrun.h"


int main ()
{

   //Result object
   FmcjResultHandle        result=0;
   FmcjStringVectorHandle  parms=0;
   char                    buffer[2000]="";

   APIRET  rc;
   FmcjExecutionServiceHandle       hService=0;
   FmcjWorklistVectorHandle         hWorklistVector=0;
   FmcjWorklistHandle               hWorklist=0;
   FmcjWorkitemVectorHandle         hWorkitemList=0;
   FmcjWorkitemHandle               hWorkitem=0;
   FmcjItemVectorHandle             hItemList=0;
   FmcjItemHandle                   hItem=0;
   FmcjReadWriteContainerHandle     hInputCont=0;
   FmcjReadWriteContainerHandle     hOutputCont=0;
   unsigned long                    ulNumItems=0;
   unsigned long                    i=0;
   unsigned long                    ulEnumValue=0;
   char                             sDesc[FMC_DESCRIPTION_LENGTH+1]="";
   char                             sWIName[FMC_WORK_ITEM_NAME_LENGTH+1]="";
   char                             sWLName[FMC_LIST_NAME_LENGTH+1]="";
   char                             sOwner[FMC_USER_ID_LENGTH+1]="";
   char                             sInputUID[33]="";
   char                             sInputPWD[33]="";
   char                             sResponse[10]="";
   bool                             bKeepName=TRUE;
   int                              iResponse=0;
    
   // *******************************************************
   // **** prompt user for a workflow userid and password ***
   // *******************************************************
   printf("Enter a defined MQSeries Workflow user ID: ");
   gets(sInputUID);
   printf("\nEnter the password for this user ID: ");
   gets(sInputPWD);
   printf("\n");

   //***Connect **********
   FmcjGlobalConnect();

   //***Allocate *********
   FmcjExecutionServiceAllocate(&hService);
 
 
   //***Logon *********
   rc=FmcjExecutionServiceLogon(hService,
                                sInputUID,
                                sInputPWD,
                                Fmc_SM_Default,
                                Fmc_SA_Reset);
   if (rc!=FMC_OK) {
      printf("Error logging on.  RC =  %u\n", rc);
      return rc;
   }
   printf("Logon for user %s is successful.\n", sInputUID);

   // ****************************************************
   // *** Query for the defined worklists for this user
   // *** Cannot use a filter
   // ****************************************************
   
   ulNumItems = 0;
   rc = FmcjExecutionServiceQueryWorklists(hService, &hWorklistVector);
   if (rc != FMC_OK) {
      printf("Error doing QueryWorklists.  rc = %u\n", rc);
   }else {
      ulNumItems=FmcjWorklistVectorSize(hWorklistVector);
      printf("Number of defined worklists for %s = %u\n",sInputUID, ulNumItems);
   }   

   // ***************************************************** 
   // *** Display attributes of each worklist for this user
   // *****************************************************

   if (ulNumItems > 0) {
      
      for (i=0; i<ulNumItems; i++) {
         printf("Worklist %u\n",i);

         // get next item in the list of Worklists 
         hWorklist=FmcjWorklistVectorNextElement(hWorklistVector);
      
         // name of the worklist
         FmcjWorklistName(hWorklist,sWLName,FMC_LIST_NAME_LENGTH);
         printf("   Name        = %s\n",sWLName);
         // description of worklist
         FmcjWorklistDescription(hWorklist,sDesc,FMC_DESCRIPTION_LENGTH);         
         printf("   Description = %s\n",sDesc);

         // type of worklist - public or private
         ulEnumValue = FmcjWorklistType(hWorklist);


         if (ulEnumValue == Fmc_LT_Private)
            printf("   Type       = Private\n");
         else {
            if (ulEnumValue == Fmc_LT_Public)
               printf("   Type       = Public\n");
            else
               printf("   Type       = Not set\n");
         }
 
         // owner of worklist
         FmcjWorklistOwnerOfList(hWorklist,sOwner,FMC_USER_ID_LENGTH);  
         printf("   OwnerOfList = %s\n", sOwner);

      } // end for
   } // endif items

   // Pause so you can read the information 
   printf("Press Enter to continue\n");
   gets(sResponse);

   // *****************************************************************
   // *** Query for all items that the logged on user has authority to access.
   // *** No specified sort criteria.
   // *** Note: Items may be on various Worklist views.
   // *** In 3.1.x, Items are no longer stored on individual worklists
   // *** in the database as is in 2.3
   // *** However, you can still get the workitems that are "on" a worklist if you wish
   // *****************************************************************

   ulNumItems=0;                                          // re-initialize value
   rc = FmcjExecutionServiceQueryItems(hService,
                                           FmcjNoFilter,  // get all items for this user          
                                           FmcjNoSortCriteria,
                                           FmcjNoThreshold,
                                           &hItemList);

   if (rc != FMC_OK) 
      printf("Error doing QueryItems.  rc = %u\n", rc);
   else {
      ulNumItems = FmcjItemVectorSize(hItemList);
      printf("Number of items for %s = %u\n",sInputUID, ulNumItems);
   }

   // *******************************************      
   // *** Display information about each item
   // *******************************************

   if (ulNumItems > 0) {
      for(i=0; i< ulNumItems; i++) {
         printf("Item # %u\n", i);
         hItem=FmcjItemVectorNextElement(hItemList);

         // name of item
         FmcjItemName(hItem, sWIName, FMC_WORK_ITEM_NAME_LENGTH);
         printf("   Name        = %s\n", sWIName);

         // description of item
         FmcjItemDescription(hItem, sDesc, FMC_DESCRIPTION_LENGTH);
         printf("   Description = %s\n", sDesc);              

         // kind of item
         ulEnumValue = FmcjItemKind(hItem);
         switch(ulEnumValue) {
            case Fmc_IT_NotSet:
               printf("   Item Kind   = NotSet\n");
               break;
            case Fmc_IT_Workitem:
               printf("   Item Kind   = Workitem\n");
               break;
            case Fmc_IT_ProcessInstanceNotification:
               printf("   Item Kind   = ProcessInstanceNotification\n");
               break;
            case Fmc_IT_FirstActivityInstanceNotification:
               printf("   Item Kind   = FirstActivityInstanceNotification\n");
               break;
            case Fmc_IT_SecondActivityInstanceNotification:
               printf("   Item Kind   = SecondActivityInstanceNotification\n");
               break;
            default:
               printf("   Item Kind   = Unknown......\n");
               break;
         } // end switch

         // kind of item activity
         ulEnumValue = FmcjWorkitemActivityKind((FmcjWorkitemHandle)hItem);
         switch(ulEnumValue) {
            case Fmc_AT_NotSet:
               printf("   Activity Kind= NotSet\n");
               break;
            case Fmc_AT_Program:
               printf("   Activity Kind= Program\n");
               break;
            case Fmc_AT_Process:
               printf("   Activity Kind= Process\n");
               break;
            case Fmc_AT_Block:
               printf("   Activity Kind= Block\n");
               break;
            default:
               printf("   Activity Kind= Unknown......\n");
               break;
         } // end switch       


         // state of item
         ulEnumValue = FmcjWorkitemState((FmcjWorkitemHandle)hItem);
         switch(ulEnumValue) {
            case Fmc_IS_NotSet:
               printf("   State       = NotSet\n");
               break;
            case Fmc_IS_Ready:
               printf("   State       = Ready\n");
               break;
            case Fmc_IS_Running:
               printf("   State       = Running\n"); 
               break;
            case Fmc_IS_Finished:
               printf("   State       = Finished\n");
               break;
            case Fmc_IS_Terminated:
               printf("   State       = Terminated\n");
               break;
            case Fmc_IS_Suspended:
               printf("   State       = Suspended\n");
               break;
            case Fmc_IS_Disabled:
               printf("   State       = Disabled\n");
               break;
            case Fmc_IS_CheckedOut:
               printf("   State       = Checked out\n");
               break;
            case Fmc_IS_InError:
               printf("   State       = InError\n");
               break;
            case Fmc_IS_Executed:
               printf("   State       = Executed\n");
               break;
            case Fmc_IS_Planning:
               printf("   State       = Planning\n");
               break;
            case Fmc_IS_ForceFinished:
               printf("   State       = Forced finished\n");
               break;
            case Fmc_IS_Terminating:
               printf("   State       = Terminating\n");
               break;
            case Fmc_IS_Deleted:
               printf("   State       = Deleted\n");
               break;
            default:
               printf("   Item Kind   = Unknown......\n");
               break;
         } // end switch


         // Pause to read info about each 
         printf("Press Enter to continue\n");
         gets(sResponse);
 
      } // end for
   } // endif items

   // ********************************************************* 
   // *** Get a new list of just ready workitems for this user
   // *********************************************************

   ulNumItems=0;                                               // re-initialize counter
   rc = FmcjExecutionServiceQueryWorkitems(hService,
                                           "STATE IN (READY)",          
                                           FmcjNoSortCriteria,
                                           FmcjNoThreshold,
                                           &hWorkitemList);

   if (rc != FMC_OK)
      printf("Error doing Query ready Workitems for user %s.  rc = %u\n", sInputUID, rc);
   else {
      ulNumItems = FmcjWorkitemVectorSize(hWorkitemList);
      printf("Number of ready workitems for %s = %u\n",sInputUID, ulNumItems);
   }

   // *****************************
   // *** List out ready workitems 
   // *****************************

   if (ulNumItems > 0) {
      for(i=0; i<ulNumItems; i++) {
        
         hWorkitem=FmcjWorkitemVectorNextElement(hWorkitemList);
         FmcjWorkitemName(hWorkitem, sWIName, FMC_WORK_ITEM_NAME_LENGTH);
         FmcjWorkitemDescription(hWorkitem, sDesc, FMC_DESCRIPTION_LENGTH);
         printf("%u. %s (%s)\n",i, sWIName, sDesc);
      } // end for

      // ***********************************************************
      // *** Allow the user to select one of the workitems to start
      // *** Enter 99 to select none of the items and to exit 
      // ***********************************************************

      printf("Enter the number of the item you want to start (or type 99 to quit): \n");
      gets(sResponse);
      iResponse=atoi(sResponse);
 
      if (iResponse !=99) {

         // ***Get to the correct item in list and Start the workitem
         if (iResponse == 0) 
            hWorkitem = FmcjWorkitemVectorFirstElement(hWorkitemList);
         else {
            if (iResponse == 1){
               FmcjWorkitemVectorFirstElement(hWorkitemList); 
               hWorkitem = FmcjWorkitemVectorNextElement(hWorkitemList);
            } else {
               FmcjWorkitemVectorFirstElement(hWorkitemList);
               for (i=1; i<=iResponse; i++) {
                  FmcjWorkitemDeallocate(&hWorkitem);  // cleanup before using again
                  hWorkitem = FmcjWorkitemVectorNextElement(hWorkitemList);
               } // end for
            } // end else response >1
         } // endelse response > 0        
        
         // This is for verification purposes (debug)    
         FmcjWorkitemName(hWorkitem, sWIName, FMC_WORK_ITEM_NAME_LENGTH);
         FmcjWorkitemDescription(hWorkitem, sDesc, FMC_DESCRIPTION_LENGTH);
         printf("Activity to start =  %s (%s)\n", sWIName, sDesc);

        // ***Make sure the Process that contains this workitem is not suspended
        ulEnumValue = FmcjWorkitemProcessInstanceState(hWorkitem);

        if ( (ulEnumValue == Fmc_PS_Suspended) || (ulEnumValue == Fmc_PS_Suspending) ) 
           printf("The workitem you selected belongs to a suspended process instance.\n");
   
        else {  // start PEA and then start workitem
      
            // *** Start the Program Execution Agent - needed to start activity
            printf("Starting Program Execution Agent........\n");
            rc = FmcjExecutionServicePEAStartUp(hService);

            if ((rc != FMC_OK) && (rc != FMC_ERROR_ALREADY_STARTED) ) 
               printf("Error starting the Program Execution Agent.  rc = %u\n", rc);
            else { 
            
               printf("Program Execution Agent started......\n");
       
               rc = FmcjWorkitemStart(hWorkitem);
               if (rc != FMC_OK) 
                  printf("Error starting workitem.  rc = %u\n", rc);
               else
                  printf("Started workitem successfully\n");

           } // end else PEA started and start workitem

         } // end else process not suspended

      } //endif item selected
     
   } // endif ready items  

   

   // *** Shutdown the Program Execution Agent
   // *** do not shutdown unless the program activity is complete!
   
// printf("Shutting down the Program Execution Agent....\n");
// rc = FmcjExecutionServicePEAShutDown(hService);
// printf("Return code of PEA ShutDown = %u\n", rc);

   //***Cleanup and Logoff *********
   FmcjWorkitemVectorDeallocate(&hWorkitemList);
   FmcjWorklistVectorDeallocate(&hWorklistVector);
   FmcjItemVectorDeallocate(&hItemList);
   FmcjItemDeallocate(&hItem);
   FmcjWorkitemDeallocate(&hWorkitem);
   FmcjWorklistDeallocate(&hWorklist);

   FmcjExecutionServiceLogoff(hService);

   //***De-allocate service **********
   FmcjExecutionServiceDeallocate(&hService);

   //***Disconnect ***************
   FmcjGlobalDisconnect();


   return 0;
} // end main