flowable 1.0.0

data/lib/flowable/resources/history.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Flowable
+  module Resources
+    class History < Base
+      # --- Historic Case Instances ---
+
+      # List historic case instances
+      # @param options [Hash] Query parameters
+      # @option options [String] :caseInstanceId Filter by case instance ID
+      # @option options [String] :caseDefinitionKey Filter by definition key
+      # @option options [String] :caseDefinitionId Filter by definition ID
+      # @option options [String] :businessKey Filter by business key
+      # @option options [String] :involvedUser Filter by involved user
+      # @option options [Boolean] :finished Only finished instances
+      # @option options [String] :finishedAfter Finished after date (ISO-8601)
+      # @option options [String] :finishedBefore Finished before date (ISO-8601)
+      # @option options [String] :startedAfter Started after date
+      # @option options [String] :startedBefore Started before date
+      # @option options [String] :startedBy Filter by starter user
+      # @option options [Boolean] :includeCaseVariables Include variables
+      # @option options [String] :tenantId Filter by tenant
+      # @return [Hash] Paginated list of historic case instances
+      def case_instances(**options)
+        params = paginate_params(options)
+        %i[caseInstanceId caseDefinitionKey caseDefinitionId businessKey
+           involvedUser startedBy tenantId tenantIdLike].each do |key|
+          params[key] = options[key] if options[key]
+        end
+
+        %i[finished includeCaseVariables withoutTenantId].each do |key|
+          params[key] = options[key] if options.key?(key)
+        end
+
+        %i[finishedAfter finishedBefore startedAfter startedBefore].each do |key|
+          params[key] = format_date(options[key]) if options[key]
+        end
+
+        client.get('cmmn-history/historic-case-instances', params)
+      end
+
+      # Get a specific historic case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Hash] Historic case instance details
+      def case_instance(case_instance_id)
+        client.get("cmmn-history/historic-case-instances/#{case_instance_id}")
+      end
+
+      # Delete a historic case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Boolean] true if successful
+      def delete_case_instance(case_instance_id)
+        client.delete("cmmn-history/historic-case-instances/#{case_instance_id}")
+      end
+
+      # Query historic case instances with complex filters
+      # Note: CMMN API doesn't support POST query endpoint, uses GET with parameters
+      # @param query [Hash] Query parameters (same as case_instances)
+      # @return [Hash] Paginated list of historic case instances
+      def query_case_instances(query)
+        # Convert query hash to keyword arguments for case_instances
+        case_instances(**query.transform_keys(&:to_sym))
+      end
+
+      # Get identity links for a historic case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Array<Hash>] List of identity links
+      def case_instance_identity_links(case_instance_id)
+        client.get("cmmn-history/historic-case-instance/#{case_instance_id}/identitylinks")
+      end
+
+      # Get stage overview for a historic case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Array<Hash>] List of stages
+      def case_instance_stage_overview(case_instance_id)
+        client.get("cmmn-history/historic-case-instances/#{case_instance_id}/stage-overview")
+      end
+
+      # --- Historic Milestones ---
+
+      # List historic milestones
+      # @param options [Hash] Query parameters
+      # @option options [String] :caseInstanceId Filter by case instance
+      # @option options [String] :caseDefinitionId Filter by case definition
+      # @option options [String] :milestoneId Filter by milestone ID
+      # @option options [String] :milestoneName Filter by name
+      # @option options [String] :reachedBefore Reached before date
+      # @option options [String] :reachedAfter Reached after date
+      # @return [Hash] Paginated list of milestones
+      def milestones(**options)
+        params = paginate_params(options)
+        %i[caseInstanceId caseDefinitionId milestoneId milestoneName].each do |key|
+          params[key] = options[key] if options[key]
+        end
+
+        %i[reachedBefore reachedAfter].each do |key|
+          params[key] = format_date(options[key]) if options[key]
+        end
+
+        client.get('cmmn-history/historic-milestone-instances', params)
+      end
+
+      # Get a specific historic milestone
+      # @param milestone_id [String] The milestone instance ID
+      # @return [Hash] Milestone details
+      def milestone(milestone_id)
+        client.get("cmmn-history/historic-milestone-instances/#{milestone_id}")
+      end
+
+      # --- Historic Plan Item Instances ---
+
+      # List historic plan item instances
+      # @param options [Hash] Query parameters
+      # @option options [String] :caseInstanceId Filter by case instance
+      # @option options [String] :caseDefinitionId Filter by case definition
+      # @option options [String] :planItemInstanceId Filter by ID
+      # @option options [String] :planItemInstanceName Filter by name
+      # @option options [String] :planItemInstanceState Filter by state
+      # @option options [String] :stageInstanceId Filter by parent stage
+      # @option options [String] :elementId Filter by element ID
+      # @option options [String] :planItemDefinitionId Filter by definition ID
+      # @option options [String] :planItemDefinitionType Filter by type
+      # @option options [String] :tenantId Filter by tenant
+      # @return [Hash] Paginated list of historic plan item instances
+      def plan_item_instances(**options)
+        params = paginate_params(options)
+        %i[caseInstanceId caseDefinitionId planItemInstanceId planItemInstanceName
+           planItemInstanceState stageInstanceId elementId planItemDefinitionId
+           planItemDefinitionType referenceId referenceType startUserId tenantId].each do |key|
+          params[key] = options[key] if options[key]
+        end
+
+        # Date filters - there are many for plan items
+        %i[createdBefore createdAfter lastAvailableBefore lastAvailableAfter
+           lastEnabledBefore lastEnabledAfter lastDisabledBefore lastDisabledAfter
+           lastStartedBefore lastStartedAfter lastSuspendedBefore lastSuspendedAfter
+           completedBefore completedAfter terminatedBefore terminatedAfter
+           occurredBefore occurredAfter exitBefore exitAfter
+           endedBefore endedAfter].each do |key|
+          params[key] = format_date(options[key]) if options[key]
+        end
+
+        params[:withoutTenantId] = options[:withoutTenantId] if options.key?(:withoutTenantId)
+
+        client.get('cmmn-history/historic-planitem-instances', params)
+      end
+
+      # Get a specific historic plan item instance
+      # @param plan_item_instance_id [String] The plan item instance ID
+      # @return [Hash] Plan item instance details
+      def plan_item_instance(plan_item_instance_id)
+        client.get("cmmn-history/historic-planitem-instances/#{plan_item_instance_id}")
+      end
+
+      # --- Historic Tasks ---
+
+      # List historic task instances
+      # @param options [Hash] Query parameters
+      # @option options [String] :taskId Filter by task ID
+      # @option options [String] :caseInstanceId Filter by case instance
+      # @option options [String] :caseDefinitionId Filter by case definition
+      # @option options [String] :taskName Filter by name
+      # @option options [String] :taskNameLike Filter by name pattern
+      # @option options [String] :taskAssignee Filter by assignee
+      # @option options [String] :taskOwner Filter by owner
+      # @option options [String] :taskInvolvedUser Filter by involved user
+      # @option options [Boolean] :finished Only finished tasks
+      # @option options [String] :tenantId Filter by tenant
+      # @return [Hash] Paginated list of historic tasks
+      def task_instances(**options)
+        params = paginate_params(options)
+        %i[taskId caseInstanceId caseDefinitionId taskDefinitionKey
+           taskName taskNameLike taskDescription taskDescriptionLike
+           taskCategory taskDeleteReason taskDeleteReasonLike
+           taskAssignee taskAssigneeLike taskOwner taskOwnerLike
+           taskInvolvedUser taskPriority parentTaskId tenantId tenantIdLike].each do |key|
+          params[key] = options[key] if options[key]
+        end
+
+        %i[finished caseFinished withoutDueDate includeTaskLocalVariables withoutTenantId].each do |key|
+          params[key] = options[key] if options.key?(key)
+        end
+
+        %i[dueDate dueDateAfter dueDateBefore taskCompletedOn taskCompletedAfter
+           taskCompletedBefore taskCreatedOn taskCreatedBefore taskCreatedAfter].each do |key|
+          params[key] = format_date(options[key]) if options[key]
+        end
+
+        client.get('cmmn-history/historic-task-instances', params)
+      end
+
+      # Get a specific historic task
+      # @param task_id [String] The task ID
+      # @return [Hash] Historic task details
+      def task_instance(task_id)
+        client.get("cmmn-history/historic-task-instances/#{task_id}")
+      end
+
+      # Delete a historic task
+      # @param task_id [String] The task ID
+      # @return [Boolean] true if successful
+      def delete_task_instance(task_id)
+        client.delete("cmmn-history/historic-task-instances/#{task_id}")
+      end
+
+      # Query historic tasks with complex filters
+      # @param query [Hash] Query body
+      # @return [Hash] Paginated list of historic tasks
+      def query_task_instances(query)
+        client.post('query/historic-task-instances', query)
+      end
+
+      # Get identity links for a historic task
+      # @param task_id [String] The task ID
+      # @return [Array<Hash>] List of identity links
+      def task_instance_identity_links(task_id)
+        client.get("cmmn-history/historic-task-instance/#{task_id}/identitylinks")
+      end
+
+      # --- Historic Variables ---
+
+      # List historic variable instances
+      # @param options [Hash] Query parameters
+      # @option options [String] :caseInstanceId Filter by case instance
+      # @option options [String] :taskId Filter by task
+      # @option options [Boolean] :excludeTaskVariables Exclude task variables
+      # @option options [String] :variableName Filter by variable name
+      # @option options [String] :variableNameLike Filter by name pattern
+      # @return [Hash] Paginated list of historic variables
+      def variable_instances(**options)
+        params = paginate_params(options)
+        %i[caseInstanceId taskId variableName variableNameLike].each do |key|
+          params[key] = options[key] if options[key]
+        end
+
+        params[:excludeTaskVariables] = options[:excludeTaskVariables] if options.key?(:excludeTaskVariables)
+
+        client.get('cmmn-history/historic-variable-instances', params)
+      end
+
+      # Query historic variables with complex filters
+      # @param query [Hash] Query body
+      # @return [Hash] Paginated list of historic variables
+      def query_variable_instances(query)
+        client.post('query/historic-variable-instances', query)
+      end
+
+      # Aliases for convenience
+      alias tasks task_instances
+      alias task task_instance
+      alias delete_task delete_task_instance
+      alias variables variable_instances
+
+      private
+
+      def format_date(date)
+        return date if date.is_a?(String)
+        return date.iso8601 if date.respond_to?(:iso8601)
+
+        date.to_s
+      end
+    end
+  end
+end

data/lib/flowable/resources/plan_item_instances.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Flowable
+  module Resources
+    class PlanItemInstances < Base
+      BASE_PATH = 'cmmn-runtime/plan-item-instances'
+
+      # List all plan item instances
+      # @param options [Hash] Query parameters
+      # @option options [String] :id Filter by ID
+      # @option options [String] :caseDefinitionId Filter by case definition
+      # @option options [String] :caseInstanceId Filter by case instance
+      # @option options [String] :stageInstanceId Filter by parent stage
+      # @option options [String] :planItemDefinitionId Filter by plan item definition
+      # @option options [String] :planItemDefinitionType Filter by type (stage, milestone, humanTask, etc.)
+      # @option options [String] :planItemDefinitionTypes Comma-separated types
+      # @option options [String] :state Filter by state (available, active, enabled, disabled, completed, etc.)
+      # @option options [String] :name Filter by name
+      # @option options [String] :elementId Filter by element ID from model
+      # @option options [String] :tenantId Filter by tenant
+      # @return [Hash] Paginated list of plan item instances
+      def list(**options)
+        params = paginate_params(options)
+        %i[id caseDefinitionId caseInstanceId stageInstanceId
+           planItemDefinitionId planItemDefinitionType planItemDefinitionTypes
+           state name elementId referenceId referenceType
+           startUserId tenantId].each do |key|
+          params[key] = options[key] if options[key]
+        end
+
+        # Date filters
+        %i[createdBefore createdAfter].each do |key|
+          params[key] = format_date(options[key]) if options[key]
+        end
+
+        params[:withoutTenantId] = options[:withoutTenantId] if options.key?(:withoutTenantId)
+
+        client.get(BASE_PATH, params)
+      end
+
+      # Get a specific plan item instance
+      # @param plan_item_instance_id [String] The plan item instance ID
+      # @return [Hash] Plan item instance details
+      def get(plan_item_instance_id)
+        client.get("#{BASE_PATH}/#{plan_item_instance_id}")
+      end
+
+      # Execute an action on a plan item instance
+      # @param plan_item_instance_id [String] The plan item instance ID
+      # @param action [String] Action to execute
+      # @return [Hash] Response
+      def execute_action(plan_item_instance_id, action)
+        client.put("#{BASE_PATH}/#{plan_item_instance_id}", { action: action })
+      end
+
+      # Start a plan item (must be in enabled state)
+      # @param plan_item_instance_id [String] The plan item instance ID
+      # @return [Hash] Response
+      def start(plan_item_instance_id)
+        execute_action(plan_item_instance_id, 'start')
+      end
+
+      # Trigger a plan item (for items waiting for trigger)
+      # @param plan_item_instance_id [String] The plan item instance ID
+      # @return [Hash] Response
+      def trigger(plan_item_instance_id)
+        execute_action(plan_item_instance_id, 'trigger')
+      end
+
+      # Enable a plan item (must be currently disabled)
+      # @param plan_item_instance_id [String] The plan item instance ID
+      # @return [Hash] Response
+      def enable(plan_item_instance_id)
+        execute_action(plan_item_instance_id, 'enable')
+      end
+
+      # Disable a plan item (must be currently enabled)
+      # @param plan_item_instance_id [String] The plan item instance ID
+      # @return [Hash] Response
+      def disable(plan_item_instance_id)
+        execute_action(plan_item_instance_id, 'disable')
+      end
+
+      # Evaluate criteria on a plan item
+      # @param plan_item_instance_id [String] The plan item instance ID
+      # @return [Hash] Response
+      def evaluate_criteria(plan_item_instance_id)
+        execute_action(plan_item_instance_id, 'evaluateCriteria')
+      end
+
+      # --- Helper methods ---
+
+      # List all active plan items for a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Hash] Paginated list of active plan items
+      def active_for_case(case_instance_id)
+        list(caseInstanceId: case_instance_id, state: 'active')
+      end
+
+      # List all stages for a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Hash] Paginated list of stages
+      def stages_for_case(case_instance_id)
+        list(caseInstanceId: case_instance_id, planItemDefinitionType: 'stage')
+      end
+
+      # List all human tasks for a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Hash] Paginated list of human tasks
+      def human_tasks_for_case(case_instance_id)
+        list(caseInstanceId: case_instance_id, planItemDefinitionType: 'humantask')
+      end
+
+      # List all milestones for a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Hash] Paginated list of milestones
+      def milestones_for_case(case_instance_id)
+        list(caseInstanceId: case_instance_id, planItemDefinitionType: 'milestone')
+      end
+
+      private
+
+      def format_date(date)
+        return date if date.is_a?(String)
+        return date.iso8601 if date.respond_to?(:iso8601)
+
+        date.to_s
+      end
+    end
+  end
+end

data/lib/flowable/resources/process_definitions.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Flowable
+  module Resources
+    class ProcessDefinitions < Base
+      BASE_PATH = 'service/repository/process-definitions'
+
+      # List all process definitions
+      # @param options [Hash] Query parameters
+      # @option options [String] :key Filter by key
+      # @option options [String] :keyLike Filter by key pattern
+      # @option options [String] :name Filter by name
+      # @option options [String] :nameLike Filter by name pattern
+      # @option options [Integer] :version Filter by version
+      # @option options [String] :deploymentId Filter by deployment
+      # @option options [Boolean] :latest Only return latest versions
+      # @option options [Boolean] :suspended Filter by suspension state
+      # @option options [String] :tenantId Filter by tenant
+      # @return [Hash] Paginated list of process definitions
+      def list(**options)
+        params = paginate_params(options)
+        %i[key keyLike name nameLike resourceName resourceNameLike
+           category categoryLike categoryNotEquals deploymentId
+           startableByUser tenantId tenantIdLike].each do |key|
+          params[key] = options[key] if options[key]
+        end
+        params[:version] = options[:version] if options[:version]
+        params[:latest] = options[:latest] if options.key?(:latest)
+        params[:suspended] = options[:suspended] if options.key?(:suspended)
+        params[:withoutTenantId] = options[:withoutTenantId] if options.key?(:withoutTenantId)
+
+        client.get(BASE_PATH, params)
+      end
+
+      # Get a specific process definition
+      # @param process_definition_id [String] The process definition ID
+      # @return [Hash] Process definition details
+      def get(process_definition_id)
+        client.get("#{BASE_PATH}/#{process_definition_id}")
+      end
+
+      # Get process definition by key (returns latest version)
+      # @param key [String] The process definition key
+      # @param tenant_id [String] Optional tenant ID
+      # @return [Hash] Process definition details
+      def get_by_key(key, tenant_id: nil)
+        params = { key: key, latest: true }
+        params[:tenantId] = tenant_id if tenant_id
+
+        result = client.get(BASE_PATH, params)
+        result['data']&.first
+      end
+
+      # Update the category of a process definition
+      # @param process_definition_id [String] The process definition ID
+      # @param category [String] The new category
+      # @return [Hash] Updated process definition
+      def update_category(process_definition_id, category)
+        client.put("#{BASE_PATH}/#{process_definition_id}", { category: category })
+      end
+
+      # Suspend a process definition
+      # @param process_definition_id [String] The process definition ID
+      # @param include_instances [Boolean] Also suspend running instances
+      # @param date [String] Effective date (ISO-8601)
+      # @return [Hash] Updated process definition
+      def suspend(process_definition_id, include_instances: false, date: nil)
+        body = { action: 'suspend', includeProcessInstances: include_instances }
+        body[:date] = date if date
+        client.put("#{BASE_PATH}/#{process_definition_id}", body)
+      end
+
+      # Activate a process definition
+      # @param process_definition_id [String] The process definition ID
+      # @param include_instances [Boolean] Also activate suspended instances
+      # @param date [String] Effective date (ISO-8601)
+      # @return [Hash] Updated process definition
+      def activate(process_definition_id, include_instances: false, date: nil)
+        body = { action: 'activate', includeProcessInstances: include_instances }
+        body[:date] = date if date
+        client.put("#{BASE_PATH}/#{process_definition_id}", body)
+      end
+
+      # Get the BPMN XML content of a process definition
+      # @param process_definition_id [String] The process definition ID
+      # @return [String] BPMN XML content
+      def resource_data(process_definition_id)
+        client.get("#{BASE_PATH}/#{process_definition_id}/resourcedata")
+      end
+
+      alias resource_content resource_data
+
+      # Get the BPMN model as JSON
+      # @param process_definition_id [String] The process definition ID
+      # @return [Hash] BPMN model structure
+      def model(process_definition_id)
+        client.get("#{BASE_PATH}/#{process_definition_id}/model")
+      end
+
+      # Get process diagram image (PNG)
+      # @param process_definition_id [String] The process definition ID
+      # @return [String] Binary image data
+      def diagram(process_definition_id)
+        client.get("#{BASE_PATH}/#{process_definition_id}/image")
+      end
+
+      alias image diagram
+
+      # Get all candidate starters for a process definition
+      # @param process_definition_id [String] The process definition ID
+      # @return [Array<Hash>] List of identity links
+      def identity_links(process_definition_id)
+        client.get("#{BASE_PATH}/#{process_definition_id}/identitylinks")
+      end
+
+      # Add a candidate starter (user) to a process definition
+      # @param process_definition_id [String] The process definition ID
+      # @param user_id [String] The user ID
+      # @return [Hash] Created identity link
+      def add_candidate_user(process_definition_id, user_id)
+        client.post("#{BASE_PATH}/#{process_definition_id}/identitylinks", { user: user_id })
+      end
+
+      # Add a candidate starter (group) to a process definition
+      # @param process_definition_id [String] The process definition ID
+      # @param group_id [String] The group ID
+      # @return [Hash] Created identity link
+      def add_candidate_group(process_definition_id, group_id)
+        client.post("#{BASE_PATH}/#{process_definition_id}/identitylinks", { group: group_id })
+      end
+
+      # Remove a candidate starter from a process definition
+      # @param process_definition_id [String] The process definition ID
+      # @param family [String] 'users' or 'groups'
+      # @param identity_id [String] The user or group ID
+      # @return [Boolean] true if successful
+      def remove_candidate(process_definition_id, family, identity_id)
+        client.delete("#{BASE_PATH}/#{process_definition_id}/identitylinks/#{family}/#{identity_id}")
+      end
+    end
+  end
+end