epm.h

Go to the documentation of this file.

/*==============================================================================
                Copyright (c) 2003-2005 UGS Corporation
                   Unpublished - All Rights Reserved
 ==============================================================================*/

/*  */

#ifndef EPM_H
#define EPM_H

#include <epm/cr.h>
#include <tc/tc_startup.h>
#include <tccore/tctype.h>
#include <epm/epm_errors.h>
#include <tc/tc_arguments.h>
#include <tccore/workspaceobject.h>
#include <epm/libepm_exports.h>


#define EPM_select_signoff_team_task     "select-signoff-team"            
#define EPM_perform_signoffs_task        "perform-signoffs"                
#define EPM_user_size_c                  163                           

typedef enum EPM_signoff_decision_e {
             EPM_no_decision         = 0,        
             EPM_approve_decision    = 'Y',        
             EPM_reject_decision     = 'N'        
} EPM_signoff_decision_t;

#define EPM_comment2_size_c               4000    
typedef enum EPM_state_e
{
    EPM_unassigned       = (1 << 0)  /* 1 */    
   ,EPM_pending          = (1 << 1)  /* 2 */    
   ,EPM_started          = (1 << 2)  /* 4 */    
   ,EPM_completed        = (1 << 3)  /* 8 */    
   ,EPM_skipped          = (1 << 4)  /* 16 */    
   ,EPM_aborted          = (1 << 5)  /* 32 */    
   ,EPM_failed           = (1 << 6)  /* 64 */    
   ,EPM_suspended        = (1 << 7)  /* 132 */    
} EPM_state_t;


#define EPM_assign_action               1        
#define EPM_start_action                2        
#define EPM_complete_action             4        
#define EPM_skip_action                 5        
#define EPM_suspend_action              6        
#define EPM_resume_action               7        
#define EPM_undo_action                 8        
#define EPM_abort_action                9        
#define EPM_fail_action                 10        
#define EPM_perform_action              100        
#define EPM_add_attachment_action       101        
#define EPM_remove_attachment_action    102        
#define EPM_approve_action              104        
#define EPM_reject_action               105        
#define EPM_promote_action              106        
#define EPM_demote_action               107        
#define EPM_refuse_action               108        
#define EPM_assign_approver_action      109        
#define EPM_notify_action               110        
#define EPM_start_on_complete_action     EPM_start_action        
#define EPM_complete_on_complete_action  EPM_complete_action    
#define EPM_start_on_fail_action         EPM_fail_action        
#define EPM_restart_on_complete_action   200                    
#define EPM_restart_on_fail_action       201                    
#define EPM_start_on_start_action        202                    
#define EPM_claim_action                 203                    
#define EPM_user_action                 1000

typedef int EPM_action_t;
#define EPM_target_attachment               1        
#define EPM_reference_attachment            3        
#define EPM_signoff_attachment              4        
#define EPM_release_status_attachment       5        
#define EPM_comment_attachment              6        
#define EPM_instruction_attachment          7        
#define EPM_interprocess_task_attachment    8        
#define EPM_schedule_task_attachment        9        
#define EPM_ATT_TARGET "target"                            
#define EPM_ATT_REFERENCE "reference"                      
#define EPM_ATT_PROCESS "process"                          
#define EPM_ATT_SIGNOFF "signoff"                          
#define EPM_ATT_COMMENT "comment"                          
#define EPM_ATT_INSTRUCTION "instruction"                  
#define EPM_ATT_INTERPROCESS_TASK "interprocess_task"      
#define EPM_ATT_SCHEDULE_TASK "schedule_task"              
#define EPM_ATT_BOTH "both"                                
#define EPM_ATT_ALL "all"                                  
#define EPM_user_attachment             1000

#define EPM_max_template_name_length    81        
#define EPM_Perform      0                
#define EPM_Review       1                
#define EPM_Acknowledge  2                
#define EPM_Notify       3                
typedef enum EPM_path_type_e{
    EPM_success_path_type,                
    EPM_failure_path_type,                
    EPM_restart_success_path_type,        
    EPM_refail_failure_path_type        
} EPM_path_type_t;

#define EPM_RESULT_Unset "Unset"                                
#define EPM_RESULT_Completed "Completed"                        
#define EPM_RESULT_Approved "Approved"                            
#define EPM_RESULT_Rejected "Rejected"                            
#define EPM_RESULT_Unable_to_complete "Unable_to_complete"        
#define EPM_RESULT_True "True"                                    
#define EPM_RESULT_False "False"                                
#define EPM_RESULT_No_error "No_error"                            
#define EPM_comment_size_c               4000

typedef struct EPM_action_message_s{
    tag_t                 task;             
    EPM_action_t          action;           
    EPM_state_t           proposed_state;   
    TC_argument_list_t* arguments;          
    tag_t                 data;             
} EPM_action_message_t;

typedef struct EPM_rule_message_s{
    tag_t                 task;               
    EPM_action_t          proposed_action;    
    TC_argument_list_t* arguments;            
    tag_t                 tag;                
} EPM_rule_message_t;

typedef enum EPM_decision_e{
    EPM_nogo,             
    EPM_undecided,        
    EPM_go                
} EPM_decision_t;

#define EPM_RESULT_TRUE                 1    
#define EPM_RESULT_FALSE                0    
#define EPM_RESULT_UNSET                2

typedef int (*EPM_action_handler_t) (EPM_action_message_t);
typedef EPM_decision_t   (*EPM_rule_handler_t)   (EPM_rule_message_t);

#define EPM_inbox_query                 1

typedef enum EPM_handler_type_e{
    EPM_rule_handler_type,                    
    EPM_action_handler_type                    
} EPM_handler_type_t;

typedef enum EPMTaskType
{
    eEPMDoTask,                        
    eEPMReviewTask,                    
    eEPMSelectSignoffTask,            
    eEPMPerformSignoffTask,            
    eEPMAcknowledgeTask,            
    eEPMConditionTask,                
    eEPMNotifyTask,                    
    eEPMRouteTask,                    
    eEPMOrTask,                        
    eEPMSyncTask,                    
    eEPMAddStatusTask,                
    eECMImpactAnalysisTask,            
    eECMPrepareECOTask,                
    eECMChecklistTask,                
    eEPMValidateTask,                
    eEPMUnknownTask                    
} EPM_task_type_t;

typedef struct EPM_resource_list_s
{
     int    count;                        
     tag_t  *resources;                    
     tag_t  *profiles;                    
     int    *actions;                    
     int    revQuorum;                    
     int    ackQuorum;                    
     int    waitForUndecidedReviewers;  
} EPM_resource_list_t;

#define EPM_TEMPLATE_BASED_ON_RELATION_TYPE "EPM_template_based_on"                
#define EPM_SIGNOFF_PROFILE_RELATION_TYPE   "EPM_signoff_profile"                
#define SUBSCRIBED_REMOTEINBOXES_RELATION_TYPE "subscribed_remoteinboxes"        
#ifdef __cplusplus
extern "C"{
#endif

extern EPM_API int EPM_init_module();

extern EPM_API int EPM_register_rule_handler(
    const char*        handler_name,           
    const char*        handler_description,    
    EPM_rule_handler_t function_pointer        
    );

extern EPM_API int EPM_register_action_handler(
    const char*          handler_name,            
    const char*          handler_description,     
    EPM_action_handler_t function_pointer         
    );

extern EPM_API int EPM_add_release_status_to_process(
    tag_t          job,             
    tag_t          release_status    
    );

extern EPM_API int EPM_ask_decision(
    tag_t                  task_tag,                         
    tag_t                  user,                            
    EPM_signoff_decision_t* decision,                       
    char                   **comments,                      
    date_t*                decision_date                     
    );

extern EPM_API int EPM_ask_if_released(
    tag_t          workspace_object,    
    int*           is_released          
    );

extern EPM_API int EPM_ask_active_job_for_target(
    tag_t          target_object,    
    int*           count,           
    tag_t**        jobs             
    );

extern EPM_API int EPM_ask_template_access(
    tag_t          task_tag,               
    int*           nb_of_accessors,          
    char***        group_names,             
    char***        role_names,              
    int**          access_codes             
    );

extern EPM_API int EPM_ask_quorum(
    tag_t          task_tag,                
    int*           quorum                  
    );

extern EPM_API int EPM_ask_release_statuses(
    tag_t          job,                     
    int*           count,                   
    tag_t**        release_status_objects   
    );

extern EPM_API int EPM_find_status_type(
    const char*    status_type,      
    tag_t*         status           
    );

extern EPM_API int EPM_remove_release_status(
    tag_t          job,             
    tag_t          release_status    
    );

extern EPM_API int EPM_remove_status_from_targets(
  tag_t         release_status,            
  tag_t         root_tag                   
                );

extern EPM_API int EPM_refresh_job(
    tag_t          job      
    );

extern EPM_API int EPM_ask_action_string(
    EPM_action_t   action,                                 
    char           string[WSO_name_size_c + 1]             
    );

extern EPM_API int EPM_ask_action_string2(
    EPM_action_t   action,                                 
    char           **string                                
    );

extern EPM_API int EPM_ask_state_string(
    EPM_state_t    state,                                  
    char           string[WSO_name_size_c + 1]             
    );

extern EPM_API int EPM_ask_state_string2(
    EPM_state_t    state,                                  
    char           **string                                
    );

extern EPM_API int EPM_ask_attachment_string(
    int            attachment_type,                        
    char           type_string[WSO_name_size_c + 1]        
    );

extern EPM_API int EPM_ask_attachment_string2(
    int            attachment_type,                        
    char           **type_string                           
    );

extern EPM_API int EPM_ask_all_procedure_names(
    int*           procedure_count,     
    char***        procedure_names      
    );

extern EPM_API int EPM_refresh_entire_job(
    tag_t          job      
    );

extern EPM_API int EPM_ask_procedure_name(
    tag_t          job,                                    
    char           procedure_name[WSO_name_size_c + 1]     
    );

extern EPM_API int EPM_ask_procedure_name2(
    tag_t          job,                       
    char           **procedure_name           
    );

extern EPM_API int EPM_ask_audit_file(
    tag_t          job,                       
    tag_t*         audit_file                 
    );

extern EPM_API int EPM_assign_responsible_party_with_comments(
    tag_t          task,                      
    tag_t          responsible_party,         
    const char*    comments                   
    );

extern EPM_API int EPM_assign_responsible_party(
    tag_t          task,                      
    tag_t          responsible_party          
    );

extern EPM_API int EPM_ask_responsible_party(
    tag_t          task,                     
    tag_t*         responsible_party          
    );

extern EPM_API int EPM_ask_state(
    tag_t          task,       
    EPM_state_t*   state       
    );

extern EPM_API int EPM_trigger_action(
    tag_t          task,               
    EPM_action_t   action,             
    const char*    comments            
    );

extern EPM_API int EPM_trigger_action_if_privileged(
    tag_t          task,               
    EPM_action_t   action,             
    const char*    comments            
    );

extern EPM_API int EPM_trigger_secure_action(
    tag_t          task,           
    EPM_action_t   action,         
    const char*    comments,       
    const char*    password        
    );

extern EPM_API int EPM_ask_attachments(
    tag_t          task,                  
    int            attachment_type,       
    int*           count,                 
    tag_t**        attachments            
    );

extern EPM_API int EPM_ask_all_attachments(
    tag_t          task,                    
    int*           count,                   
    tag_t**        attachments,             
    int**          attachment_types         
    );

extern EPM_API int EPM_ask_typed_attachments(
  tag_t         task,                                  
  const char*   object_type,                           
  int*          count,                                 
  tag_t**       attachments                            
   );

extern EPM_API int EPM_add_attachments(
    tag_t          task,                  
    int            count,                 
    const tag_t*   attachments,           
    const int*     attachment_types       
    );

extern EPM_API int EPM_remove_attachments(
    tag_t          task,               
    int            count,              
    const tag_t*   attachments         
    );

extern EPM_API int EPM_ask_assigned_tasks(
    tag_t          responsible_party,      
    int            query,                  
    int*           count,                  
    tag_t**        tasks                   
    );

extern EPM_API int EPM_ask_root_task(
    tag_t          job_or_task,        
    tag_t*         root_task           
    );

extern EPM_API int EPM_ask_sub_tasks(
    tag_t          task,         
    int*           count,        
    tag_t**        tasks         
    );

extern EPM_API int EPM_ask_sub_task(
    tag_t          task,                
    const char*    sub_task_name,       
    tag_t*         sub_task             
    );

extern EPM_API int EPM_ask_parent_task(
    tag_t          task,             
    tag_t*         parent_task       
    );

extern EPM_API int EPM_ask_name(
    tag_t          task,                            
    char           name[WSO_name_size_c + 1]        
    );

extern EPM_API int EPM_ask_name2(
    tag_t          task,                            
    char           **name                           
    );

extern EPM_API int EPM_ask_description(
    tag_t          task,                                   
    char           description[WSO_desc_size_c + 1]        
    );

extern EPM_API int EPM_ask_description2(
    tag_t          task,                                   
    char           **description                           
    );

extern EPM_API int EPM_ask_job(
    tag_t          task,     
    tag_t*         job       
    );

extern EPM_API int EPM_search_task_in_job(
    tag_t          task,          
    const char*    task_name,      
    tag_t*         sub_task        
    );

extern EPM_API int EPM_ask_task_dependencies(
    const tag_t    task,                     
    int*           nb_of_predecessors,       
    tag_t**        predecessor_tasks         
    );

extern EPM_API int EPM_ask_assigned_processes (
    tag_t          object_type,         
    const char*    group_name,          
    int*           count,               
    char***        process_names        
    );

extern EPM_API int EPM_ask_default_process(
    const char     object_type[WSO_name_size_c + 1],       
    char           process_name[WSO_name_size_c + 1]       
    );

extern EPM_API int EPM_ask_default_process2(
    const char     *object_type,        
    char           **process_name       
    );

extern EPM_API int EPM_ask_default_process_for(
    tag_t          workspace_object,                       
    char           process_name[WSO_name_size_c + 1]       
    );

extern EPM_API int EPM_ask_default_process_for2(
    tag_t          workspace_object,                       
    char           **process_name                          
    );

extern EPM_API int EPM_remove_task_hold(
    tag_t          task_tag          
    );

extern EPM_API int EPM_get_resource_pool(
    tag_t          group,           
    tag_t          role,            
    logical        allow_subgroup,  
    tag_t*         resourcepool     
    );

extern EPM_API int EPM_ask_resourcepool(
    tag_t          group,           
    tag_t          role,            
    logical        allow_subgroup,  
    logical        all_members,     
    tag_t*         resourcepool     
    );

extern EPM_API int EPM_ask_resource_pool_group_role(
    tag_t          resourcepool,     
    tag_t*         group,            
    tag_t*         role,             
    logical*       allow_subgroup    
    );

extern EPM_API int EPM_get_resource_pool_name(
    tag_t          resourcepool,       
    char**         resourcepool_name   
    );

extern EPM_API int EPM_ask_resource_pool_subscribers(
    tag_t           resourcepool,          
    int*            u_count,               
    tag_t**         u_tags                 
    );

extern EPM_API int EPM_ask_out_of_office(
    tag_t          user,             
    tag_t*         delegate,         
    date_t*        start_date,       
    date_t*        end_date          
    );

extern EPM_API int EPM_set_out_of_office(
    tag_t          user,            
    tag_t          delegate,        
    date_t         start_date,       
    date_t         end_date          
    );

extern EPM_API int EPM_set_out_of_office_delegate(
    tag_t          user,             
    tag_t          delegate          
    );

extern EPM_API int EPM_set_out_of_office_dates(
    tag_t          user,             
    date_t         start_date,       
    date_t         end_date          
    );

extern EPM_API int EPM_set_task_due_date(
    tag_t          task,             
    date_t         due_date          
    );

extern EPM_API int EPM_reset_task_due_date(
    tag_t          task           
    );

extern EPM_API int EPM_ask_task_due_date(
    tag_t          task,            
    date_t*        due_date         
    );

extern EPM_API int EPM_set_task_late(
    tag_t          task,            
    logical        late_flag        
    );

extern EPM_API int EPM_ask_task_late(
    tag_t          task,           
    logical*       late_flag       
    );

extern EPM_API int EPM_set_task_duration(
    tag_t          task,             
    int            years,            
    int            weeks,            
    int            days,             
    int            hours,            
    int            minutes           
    );

extern EPM_API int EPM_ask_task_duration(
    tag_t          task,           
    int*           yrs,            
    int*           wks,            
    int*           dys,            
    int*           hrs,            
    int*           mns             
    );

extern EPM_API int EPM_ask_users_late_tasks(
    tag_t          user,           
    int*           count,          
    tag_t**        late_tasks       
    );

extern EPM_API int EPM_add_subscribed_resource_pools(
    tag_t          user,           
    int            count,          
    const tag_t*   resourcepools   
    );

extern EPM_API int EPM_remove_subscribed_resource_pools(
    tag_t          user,           
    int            count,          
    const tag_t*   resourcepools   
    );

extern EPM_API int EPM_set_subscribed_remote_inboxes(
    tag_t user,                 
    int count,                  
    const tag_t *site_tags       
    );

extern EPM_API int EPM_remove_all_subscribed_remote_inboxes(
    tag_t user            
    );

extern EPM_API int EPM_ask_subscribed_remote_inboxes(
    tag_t user,            
    int *count,            
    tag_t **site_tags       
    );

extern EPM_API int EPM_ask_remote_inbox(
    tag_t    user,              
    tag_t    site,              
    tag_t*   remote_inbox        
    );

extern EPM_API int EPM_ask_subscribed_resource_pools(
    tag_t          user,          
    int*           count,         
    tag_t**        resourcepools  
    );

extern EPM_API int EPM_ask_late_task_recipients(
    tag_t          task,           
    int*           count,          
    tag_t**        recipients      
    );

extern EPM_API int EPM_set_late_task_recipients(
    tag_t          task,                       
    int            count,                      
    const tag_t*   recipient_tags               
    );


extern EPM_API int EPM_ask_recipients_for_token(
    tag_t          task,                
    const char*    token,               
    int*           count,               
    tag_t**        recipient_tags       
    );

/* --------------------------------------------------------------------------------------- */
extern EPM_API int EPM_ask_participants_for_token(
    tag_t       task,                  
    const char* token,                 
    int         *gmcount,              
    tag_t       **gmtags,              
    int         *rpcount,              
    tag_t       **rptags               
    );

extern EPM_API int EPM_add_resource_pool_recipients_for_preference(
    tag_t          task,                   
    int            *count,                 
    tag_t          **recipient_tags        
    );

extern EPM_API int EPM_set_adhoc_signoff_selection_done(
    tag_t          task,                
    logical        selection_done       
    );

extern EPM_API int EPM_get_adhoc_signoff_selection_done(
    tag_t          task,                    
    logical*       selection_done           
    );

extern EPM_API int EPM_set_condition_task_result(
    tag_t          task,                 
    int            condition             
    );

extern EPM_API int EPM_get_condition_task_result(
    tag_t          task,               
    int*           condition           
    );

extern EPM_API int EPM_demote_task(
    const tag_t    task_tag,       
    const char*    comments        
    );

extern EPM_API int EPM_promote_task(
    const tag_t    task_tag,        
    const char*    comments         
    );

extern EPM_API int EPM_ask_review_task_name(
    const tag_t    task_tag,                                   
    char           review_task_name[WSO_name_size_c+1]         
    );

extern EPM_API int EPM_ask_review_task_name2(
    const tag_t    task_tag,                                  
    char           **review_task_name                         
    );

extern EPM_API int EPM_ask_review_task_names(
    tag_t          task_tag,                   
    int*           count,                      
    char***        review_task_names           
    );

extern EPM_API int EPM_get_type_tasks(
    const tag_t           job_tag,           
    const EPM_task_type_t task_type,         
    int*                  number_of_tasks,   
    tag_t**               task_tags          
    );

extern EPM_API int EPM_set_decision(
    tag_t                 task_tag,                          
    tag_t                 user,                              
    CR_signoff_decision_t descision,                         
    const char            comments[CR_comment_size_c + 1],   
    const logical         auto_complete                      
    );

extern EPM_API int EPM_set_task_decision(
    tag_t                 task_tag,                          
    tag_t                 signoffTag,                        
    CR_signoff_decision_t descision,                         
    const char            comments[CR_comment_size_c + 1]    
    );

extern EPM_API int EPM_set_task_decision2(
    tag_t                 task_tag,                  
    tag_t                 signoff_tag,               
    CR_signoff_decision_t descision,                 
    const char            *comments                  
    );

extern EPM_API int EPM_set_secure_task_decision(
    tag_t                 task_tag,                          
    tag_t                 signoff_tag,                       
    CR_signoff_decision_t descision,                         
    const char            comments[CR_comment_size_c + 1],   
    const char*           password                           
    );

extern EPM_API int EPM_set_secure_task_decision2(
    tag_t                 task_tag,                          
    tag_t                 signoff_tag,                       
    CR_signoff_decision_t descision,                         
    const char            *comments,                         
    const char*           password                           
    );


extern EPM_API int EPM_ask_assigned_process_templates(
    int            number_of_object_type_names,      
    char**         object_type_names,                
    const char*    group_name,                       
    int*           count,                            
    tag_t**        process_templates                 
    );

extern EPM_API int EPM_is_valid_performer(
    tag_t          task,         
    logical*       valid         
    );

extern EPM_API int EPM_ask_required_reviewer_types(
    tag_t          task,                     
    int*           count,                    
    tag_t**        required_accessors        
    );

extern EPM_API int EPM_ask_accessor_tags(
    tag_t          group,              
    logical        allow_subgroups,    
    tag_t          role,               
    int*           n_accessors,        
    tag_t**        accessors           
    );

extern EPM_API int EPM_create_process_deferred_start(
    const char*    name,                               /* <I> Name of the process */
    const char*    description,                        /* <I> Process description */
    const tag_t    process_template,                    /* <I> Process template tag */
    int            attachment_count,                    /* <I> Number of attachments */
    const tag_t*   attachments,                        /* <I> Attachments to the process */
    const int*     attachment_types,                    /* <I> Attachment types like target or reference */
    tag_t*         new_process                          /* <O> New process */
);

extern EPM_API int EPM_create_process(
    const char*          name,                 
    const char*          description,          
    const tag_t          process_template,      
    int                  attachment_count,      
    const tag_t*         attachments,          
    const int*           attachment_types,      
    tag_t*               new_process            
    );

extern EPM_API int EPM_create_assigned_process(
  const char*        name,              
  const char*        description,       
  tag_t              process_template,  
  const char*        privileged_user,   
  int                user_count,        
  char**             user_list,         
  date_t             due_date,          
  int                attachment_count,  
  const tag_t*       attachment_list,   
  const int*         attachment_types,  
  const char*        container_uid,     
  char*              relation_name,     
  tag_t*        new_process        
  );


extern EPM_API int EPM_ask_tasks(
    const tag_t    process,       
    EPM_state_t    task_state,    
    int*           count,         
    tag_t**        tasks          
    );

extern EPM_API int EPM_ask_task_result_dependency(
    const tag_t    dependent_task,        
    const tag_t    predecessor_task,      
    int*           result                 
    );

extern EPM_API int EPM_clear_process_stage(
    const          tag_t task          
    );

extern EPM_API int EPM_ask_task_forms(
    const tag_t    task,     
    int*           count,    
    tag_t**        forms     
    );

extern EPM_API int EPM_ask_unassigned_profiles(
    tag_t          job,                        
    tag_t          task,                       
    int*           count,                      
    tag_t**        unassigned_profile_tags     
    );

extern EPM_API int EPM_ask_unassigned_roles(
    tag_t          job,                        
    tag_t          task,                       
    int*           count,                      
    char***        unassigned_role_names       
    );

extern EPM_API int EPM_ask_unassigned_profile_names(
    tag_t          task,                       
    int*           count,                      
    char***        unassigned_profile_names    
    );

extern EPM_API int EPM_ask_required_roles(
    tag_t          job,                        
    tag_t          task,                       
    int*           count,                      
    char***        required_role_names         
    );

extern EPM_API int EPM_ask_required_profile_names(
    tag_t          task,                       
    int*           count,                      
    char***        required_profile_names      
    );

extern EPM_API int EPM_attach_sub_processes(
    tag_t          parent_process_tag,         
    int            count,                      
    const tag_t*   secondary_processes_tags    
    );

extern EPM_API int EPM_remove_sub_processes(
    tag_t          parent_process_tag,         
    int            count,                      
    const tag_t*   secondary_processes_tags    
    );

extern EPM_API int EPM_ask_sub_processes(
    tag_t          parent_process_tag,         
    int*           count,                      
    tag_t**        secondary_processes_tags    
    );

extern EPM_API int EPM_ask_parent_processes(
    tag_t          subprocess_tag,            
    int*           count,                     
    tag_t**        parent_processes_tags      
    );

extern EPM_API int EPM_assignment_list_create(
    const char*                   list_name,         
    int                           desc_length,       
    char**                       desc_array,        
    tag_t                         proc_template,     
    logical                       is_shared,         
    int                           resources_count,   
    const tag_t*                  templates_array,   
    const EPM_resource_list_t*    resources,         
    tag_t*                        new_assn_List      
);

extern EPM_API int EPM_assignment_list_edit(
    tag_t                         assn_list,         
    const char*                   list_name,         
    int                           desc_length,       
    char**                        desc_array,        
    tag_t                         proc_template,     
    logical                       is_shared,         
    int                           resources_count,   
    const tag_t*                  templates_array,   
    const EPM_resource_list_t*    resources          
);

extern EPM_API int EPM_assignment_list_describe(
    tag_t           assn_list,          
    char**          list_name,          
    int*            desc_length,        
    char***         desc_array,         
    logical*        is_shared,          
    tag_t*          proc_template,      
    int*            resources_count,    
    tag_t**         templates_array,    
    tag_t**         resources           
);

extern EPM_API int EPM_resource_list_create(
    int          count,        
    const tag_t  *resources,   
    const tag_t  *profiles,    
    const int    *actions,     
    int          rev_quorum,    
    int          ack_quorum,    
    int          wait_for_undecided_reviewers, 
    tag_t*       resource_list 
);

extern EPM_API int EPM_resource_list_edit(
    tag_t         resource_list,  
    int           count,          
    const tag_t   *resources,     
    const tag_t   *profiles,      
    const int     *actions,       
    int           rev_quorum,     
    int           ack_quorum,     
    int           wait_for_undecided_reviewers 
);

extern EPM_API int EPM_resource_list_describe(
    tag_t   resource_list,                      
    int     *rev_quorum,                        
    int     *ack_quorum,                        
    int     *wait_for_undecided_reviewers,      
    int     *count,                             
    tag_t   **resources,                        
    tag_t   **profiles,                         
    int     **actions                           
);

extern EPM_API int EPM_find_assignment_lists(
    tag_t    resource,         
    int      *num_of_lists,    
    tag_t    **lists           
);

extern EPM_API int EPM_replace_resource_in_lists(
    int      count,                   
    const tag_t    *assn_lists,       
    tag_t    old_resource,            
    tag_t    new_resource             
);

extern EPM_API int  EPM_get_assignment_list(
    char    *list_name,  
    tag_t   *assn_list   
);

extern EPM_API int EPM_assignment_list_extent(
    int*     n_instances,   
    tag_t**  instance_tags  
);

extern EPM_API int EPM_get_all_assignment_lists(
    int*     n_own_lists,        
    tag_t**  own_list_tags,      
    int*     n_group_lists,      
    tag_t**  group_list_tags,    
    int*     n_other_lists,      
    tag_t**  other_list_tags     
);

extern EPM_API int EPM_assign_assignment_list(
    tag_t    process,             
    tag_t    assignment_list      
);

extern EPM_API int EPM_assign_to_all_tasks(
    tag_t                          assignment_list,     
    int                            num_of_templates,    
    const tag_t*                   task_templates,      
    const EPM_resource_list_t*     resources,           
    tag_t                          process              
);

extern EPM_API int EPM_set_surrogate_user(
    tag_t   user,                
    tag_t   surrogate_user,      
    date_t  start_date,          
    date_t  end_date             
);

extern EPM_API int EPM_remove_surrogate_user(
    tag_t   user,              
    tag_t   surrogate_user,    
    int     *count,            
    tag_t   **claimed_tasks    
);

extern EPM_API int EPM_claim_as_surrogate(
    tag_t    task_or_signoff,    
    logical  xfer_checkouts,     
    int      *exceptions_count,  
    tag_t    **exceptions_list   
);

extern EPM_API int EPM_get_current_surrogates(
    int             user_count,        
    const tag_t*    users,             
    int*            surrogate_count,   
    tag_t**         surrogate_users    
);

extern EPM_API int  EPM_release_claim(
    tag_t   task_or_signoff,    
    logical xfer_checkouts,     
    int     *exceptions_count,  
    tag_t   **exceptions_list   
);

extern EPM_API int EPM_get_assignmentlists_by_job(
    tag_t    job_tag,            
    int*     n_own_lists,        
    tag_t**  own_list_tags,      
    int*     n_group_lists,      
    tag_t**  group_list_tags,    
    int*     n_other_lists,      
    tag_t**  other_list_tags     
);

extern EPM_API int EPM_assnlist_get_proc_template(
    tag_t    assn_list,          
    tag_t*   process_template    
);

extern EPM_API int EPM_set_task_result(
    tag_t          task,                 
    const char*    result                
    );

extern EPM_API int EPM_get_task_result(
    tag_t          task,               
    char**         result              
    );

extern EPM_API int EPM_add_reviewers(
    tag_t          job,                    
    const char*    review_task_name,       
    int            add_excess_as_adhoc,    
    int            n_groupmembers,         
    tag_t*         groupmembers            
    );

extern EPM_API int EPM_add_reviewers_on_task (
    tag_t          sst_task,               
    logical        add_excess_as_adhoc,    
    int            n_group_members,        
    const tag_t *  group_members           
);

extern EPM_API int EPM_get_wait_for_undecided_reviewers(
    tag_t          task,                     
    int*           undecided_reviewer_count  
    );


extern EPM_API int EPM_create_participant(
    tag_t        assignee,                       
    tag_t        participant_type,               
    tag_t*       participant                     
);

extern EPM_API int EPM_get_participanttype(
    char*       type_name,                         
    tag_t*      participant_type                   
);

extern EPM_API int EPM_get_participants(
    const char* participant_value,     
    tag_t       task,                  
    int*        member_count,          
    tag_t**     members,               
    int*        rp_count,              
    tag_t**     rps,                   
    logical     single_participant     
);

extern EPM_API int EPM_get_participant(
    const char* participant_value,     
    tag_t       task,                  
    tag_t*      member,                
    tag_t*      rp,                    
    logical*    is_resourcepool        
);

extern EPM_API int EPM_claim_task(
    tag_t                 task_tag,                          
    tag_t                 signoff                            
);


/*
    Checks if the provided Task is claimable by the currently logged-in user.

    If the task is assigned to resource pool and the logged-in user is 
    neither dba, nor the task responsible party, nor the owner of the job, the returned value @p allow_claim is false. 
    <br/>Otherwise, the returned value @p allow_claim is true.

    @returns
    <ul>
    <li>#ITK_ok on success
    <li>#EPM_invalid_argument if the @p task is #NULLTAG
    <li>#EPM_invalid_object if the @p is not a valid Task
    </ul>


*/
extern EPM_API int EPM_is_task_claimable(
    tag_t          task,            
    logical*       allow_claim      
    );

/*
    Checks if the logged-in User has the specified privilege on the target object(s) of a given task.

    @returns
    <ul>
    <li>#ITK_ok on success
    <li>#EPM_invalid_object if the input task tag is incorrect
    <li>#EPM_access_denied if the privilege name is incorrect
    </ul>
*/
extern EPM_API int EPM_check_access(
    tag_t         task,            
    const char *  privilege,       
    logical*      verdict          
    );

#ifdef __cplusplus
}
#endif

#define EBR_decision_t                  EPM_decision_t            
#define EBR_undecided                   EPM_undecided            
#define EBR_nogo                        EPM_nogo                
#define EBR_go                          EPM_go                    
#define EPM_task_action_t               EPM_action_t            
#define EPM_task_state_t                EPM_state_t                
#define EPM_assign_task                 EPM_assign_action        
#define EPM_start_task                  EPM_start_action        
#define EPM_complete_task               EPM_complete_action        
#define EPM_skip_task                   EPM_skip_action            
#define EPM_suspend_task                EPM_suspend_action        
#define EPM_resume_task                 EPM_resume_action        
#define EPM_undo_task                   EPM_undo_action            
#define EPM_abort_task                  EPM_abort_action        
#define EPM_do_task                     EPM_perform_action        
#define EPM_project_task_attachment     EPM_schedule_task_attachment

#include <epm/libepm_undef.h>
#endif