flowable 1.0.0

data/lib/flowable/resources/case_definitions.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Flowable
+  module Resources
+    class CaseDefinitions < Base
+      BASE_PATH = 'cmmn-repository/case-definitions'
+
+      # List all case 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 [String] :tenantId Filter by tenant
+      # @return [Hash] Paginated list of case definitions
+      def list(**options)
+        params = paginate_params(options)
+        %i[key keyLike name nameLike resourceName resourceNameLike
+           category categoryLike categoryNotEquals deploymentId
+           startableByUser tenantId].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)
+
+        client.get(BASE_PATH, params)
+      end
+
+      # Get a specific case definition
+      # @param case_definition_id [String] The case definition ID
+      # @return [Hash] Case definition details
+      def get(case_definition_id)
+        client.get("#{BASE_PATH}/#{case_definition_id}")
+      end
+
+      # Get case definition by key (returns latest version)
+      # @param key [String] The case definition key
+      # @param tenant_id [String] Optional tenant ID
+      # @return [Hash] Case 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 case definition
+      # @param case_definition_id [String] The case definition ID
+      # @param category [String] The new category
+      # @return [Hash] Updated case definition
+      def update_category(case_definition_id, category)
+        client.put("#{BASE_PATH}/#{case_definition_id}", { category: category })
+      end
+
+      # Get the CMMN XML content of a case definition
+      # @param case_definition_id [String] The case definition ID
+      # @return [String] CMMN XML content
+      def resource_data(case_definition_id)
+        client.get("#{BASE_PATH}/#{case_definition_id}/resourcedata")
+      end
+
+      alias resource_content resource_data
+
+      # Get the CMMN model as JSON
+      # @param case_definition_id [String] The case definition ID
+      # @return [Hash] CMMN model structure
+      def model(case_definition_id)
+        client.get("#{BASE_PATH}/#{case_definition_id}/model")
+      end
+
+      # Get all candidate starters for a case definition
+      # @param case_definition_id [String] The case definition ID
+      # @return [Array<Hash>] List of identity links
+      def identity_links(case_definition_id)
+        client.get("#{BASE_PATH}/#{case_definition_id}/identitylinks")
+      end
+
+      # Add a candidate starter (user) to a case definition
+      # @param case_definition_id [String] The case definition ID
+      # @param user_id [String] The user ID
+      # @return [Hash] Created identity link
+      def add_candidate_user(case_definition_id, user_id)
+        client.post(
+          "#{BASE_PATH}/#{case_definition_id}/identitylinks",
+          { user: user_id }
+        )
+      end
+
+      # Add a candidate starter (group) to a case definition
+      # @param case_definition_id [String] The case definition ID
+      # @param group_id [String] The group ID
+      # @return [Hash] Created identity link
+      def add_candidate_group(case_definition_id, group_id)
+        client.post(
+          "#{BASE_PATH}/#{case_definition_id}/identitylinks",
+          { groupId: group_id }
+        )
+      end
+
+      # Remove a candidate starter from a case definition
+      # @param case_definition_id [String] The case 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(case_definition_id, family, identity_id)
+        client.delete("#{BASE_PATH}/#{case_definition_id}/identitylinks/#{family}/#{identity_id}")
+      end
+    end
+  end
+end

data/lib/flowable/resources/case_instances.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Flowable
+  module Resources
+    class CaseInstances < Base
+      BASE_PATH = 'cmmn-runtime/case-instances'
+
+      # List all case instances
+      # @param options [Hash] Query parameters
+      # @option options [String] :id Filter by 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] :includeCaseVariables Include variables in response
+      # @option options [String] :tenantId Filter by tenant
+      # @return [Hash] Paginated list of case instances
+      def list(**options)
+        params = paginate_params(options)
+        %i[id caseDefinitionKey caseDefinitionId businessKey
+           involvedUser tenantId tenantIdLike].each do |key|
+          params[key] = options[key] if options[key]
+        end
+        params[:includeCaseVariables] = options[:includeCaseVariables] if options.key?(:includeCaseVariables)
+        params[:withoutTenantId] = options[:withoutTenantId] if options.key?(:withoutTenantId)
+
+        client.get(BASE_PATH, params)
+      end
+
+      # Get a specific case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Hash] Case instance details
+      def get(case_instance_id)
+        client.get("#{BASE_PATH}/#{case_instance_id}")
+      end
+
+      # Start a new case instance by case definition ID
+      # @param case_definition_id [String] The case definition ID
+      # @param variables [Hash] Optional variables (name => value)
+      # @param business_key [String] Optional business key
+      # @param return_variables [Boolean] Return variables in response
+      # @return [Hash] Created case instance
+      def start_by_id(case_definition_id, variables: {}, business_key: nil, return_variables: false)
+        body = { caseDefinitionId: case_definition_id }
+        body[:businessKey] = business_key if business_key
+        body[:variables] = build_variables_array(variables) unless variables.empty?
+        body[:returnVariables] = return_variables if return_variables
+
+        client.post(BASE_PATH, body)
+      end
+
+      # Start a new case instance by case definition key
+      # @param case_definition_key [String] The case definition key
+      # @param variables [Hash] Optional variables (name => value)
+      # @param business_key [String] Optional business key
+      # @param tenant_id [String] Optional tenant ID
+      # @param return_variables [Boolean] Return variables in response
+      # @return [Hash] Created case instance
+      def start_by_key(case_definition_key, variables: {}, business_key: nil, tenant_id: nil, return_variables: false)
+        body = { caseDefinitionKey: case_definition_key }
+        body[:businessKey] = business_key if business_key
+        body[:tenantId] = tenant_id if tenant_id
+        body[:variables] = build_variables_array(variables) unless variables.empty?
+        body[:returnVariables] = return_variables if return_variables
+
+        client.post(BASE_PATH, body)
+      end
+
+      # Delete a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Boolean] true if successful
+      def delete(case_instance_id)
+        client.delete("#{BASE_PATH}/#{case_instance_id}")
+      end
+
+      # Query case instances with complex filters
+      # @param query [Hash] Query body with filters and variable conditions
+      # @return [Hash] Paginated list of case instances
+      def query(query)
+        client.post('query/case-instances', query)
+      end
+
+      # Get the diagram/image for a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [String] Binary image data
+      def diagram(case_instance_id)
+        client.get("#{BASE_PATH}/#{case_instance_id}/diagram")
+      end
+
+      # Get the stage overview for a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Array<Hash>] List of stages with their status
+      def stage_overview(case_instance_id)
+        client.get("#{BASE_PATH}/#{case_instance_id}/stage-overview")
+      end
+
+      # --- Identity Links ---
+
+      # Get involved people for a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Array<Hash>] List of identity links
+      def identity_links(case_instance_id)
+        client.get("#{BASE_PATH}/#{case_instance_id}/identitylinks")
+      end
+
+      # Add an involved user to a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @param user_id [String] The user ID
+      # @param type [String] Type of involvement (e.g., 'participant')
+      # @return [Hash] Created identity link
+      def add_involved_user(case_instance_id, user_id, type: 'participant')
+        client.post(
+          "#{BASE_PATH}/#{case_instance_id}/identitylinks",
+          { userId: user_id, type: type }
+        )
+      end
+
+      # Remove an involved user from a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @param user_id [String] The user ID
+      # @param type [String] Type of involvement
+      # @return [Boolean] true if successful
+      def remove_involved_user(case_instance_id, user_id, type)
+        client.delete("#{BASE_PATH}/#{case_instance_id}/identitylinks/users/#{user_id}/#{type}")
+      end
+
+      # --- Variables ---
+
+      # Get all variables for a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @return [Array<Hash>] List of variables
+      def variables(case_instance_id)
+        client.get("#{BASE_PATH}/#{case_instance_id}/variables")
+      end
+
+      # Get a specific variable from a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @param variable_name [String] The variable name
+      # @return [Hash] Variable details
+      def variable(case_instance_id, variable_name)
+        client.get("#{BASE_PATH}/#{case_instance_id}/variables/#{variable_name}")
+      end
+
+      # Create variables on a case instance (fails if exists)
+      # @param case_instance_id [String] The case instance ID
+      # @param variables [Hash] Variables to create (name => value)
+      # @return [Array<Hash>] Created variables
+      def create_variables(case_instance_id, variables)
+        client.post(
+          "#{BASE_PATH}/#{case_instance_id}/variables",
+          build_variables_array(variables)
+        )
+      end
+
+      # Create or update variables on a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @param variables [Hash] Variables to set (name => value)
+      # @return [Array<Hash>] Updated variables
+      def set_variables(case_instance_id, variables)
+        client.put(
+          "#{BASE_PATH}/#{case_instance_id}/variables",
+          build_variables_array(variables)
+        )
+      end
+
+      # Update a single variable on a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @param name [String] Variable name
+      # @param value [Object] Variable value
+      # @param type [String] Optional explicit type
+      # @return [Hash] Updated variable
+      def update_variable(case_instance_id, name, value, type: nil)
+        body = { name: name, value: value }
+        body[:type] = type || infer_type(value)
+
+        client.put("#{BASE_PATH}/#{case_instance_id}/variables/#{name}", body)
+      end
+
+      # Delete a variable from a case instance
+      # @param case_instance_id [String] The case instance ID
+      # @param variable_name [String] The variable name
+      # @return [Boolean] true if successful
+      def delete_variable(case_instance_id, variable_name)
+        client.delete("#{BASE_PATH}/#{case_instance_id}/variables/#{variable_name}")
+      end
+    end
+  end
+end

data/lib/flowable/resources/deployments.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Flowable
+  module Resources
+    class Deployments < Base
+      BASE_PATH = 'cmmn-repository/deployments'
+
+      # List all deployments
+      # @param options [Hash] Query parameters
+      # @option options [String] :name Filter by exact name
+      # @option options [String] :nameLike Filter by name pattern (use % wildcard)
+      # @option options [String] :category Filter by category
+      # @option options [String] :tenantId Filter by tenant
+      # @option options [Integer] :start Pagination start (default: 0)
+      # @option options [Integer] :size Page size (default: 10)
+      # @option options [String] :sort Sort field (id/name/deployTime/tenantId)
+      # @option options [String] :order Sort order (asc/desc)
+      # @return [Hash] Paginated list of deployments
+      def list(**options)
+        params = paginate_params(options)
+        params[:name] = options[:name] if options[:name]
+        params[:nameLike] = options[:nameLike] if options[:nameLike]
+        params[:category] = options[:category] if options[:category]
+        params[:tenantId] = options[:tenantId] if options[:tenantId]
+        params[:withoutTenantId] = options[:withoutTenantId] if options[:withoutTenantId]
+
+        client.get(BASE_PATH, params)
+      end
+
+      # Get a specific deployment
+      # @param deployment_id [String] The deployment ID
+      # @return [Hash] Deployment details
+      def get(deployment_id)
+        client.get("#{BASE_PATH}/#{deployment_id}")
+      end
+
+      # Create a new deployment from a file
+      # @param file_path [String] Path to CMMN file (.cmmn.xml, .bar, .zip)
+      # @param name [String] Optional deployment name
+      # @param tenant_id [String] Optional tenant ID
+      # @param category [String] Optional category
+      # @return [Hash] Created deployment
+      def create(file_path, name: nil, tenant_id: nil, category: nil)
+        additional_fields = {}
+        additional_fields[:deploymentName] = name if name
+        additional_fields[:tenantId] = tenant_id if tenant_id
+        additional_fields[:category] = category if category
+
+        client.post_multipart(BASE_PATH, file_path, additional_fields)
+      end
+
+      # Delete a deployment
+      # @param deployment_id [String] The deployment ID
+      # @param cascade [Boolean] Also delete related case/process instances (default: false)
+      # @return [Boolean] true if successful
+      def delete(deployment_id, cascade: false)
+        params = cascade ? { cascade: true } : {}
+        client.delete("#{BASE_PATH}/#{deployment_id}", params)
+      end
+
+      # List resources in a deployment
+      # @param deployment_id [String] The deployment ID
+      # @return [Array<Hash>] List of resources
+      def resources(deployment_id)
+        client.get("#{BASE_PATH}/#{deployment_id}/resources")
+      end
+
+      # Get a specific resource from a deployment
+      # @param deployment_id [String] The deployment ID
+      # @param resource_id [String] The resource ID (URL-encoded if contains /)
+      # @return [Hash] Resource details
+      def resource(deployment_id, resource_id)
+        encoded_resource_id = URI.encode_www_form_component(resource_id)
+        client.get("#{BASE_PATH}/#{deployment_id}/resources/#{encoded_resource_id}")
+      end
+
+      # Get the content of a deployment resource
+      # @param deployment_id [String] The deployment ID
+      # @param resource_id [String] The resource ID
+      # @return [String] Raw resource content
+      def resource_data(deployment_id, resource_id)
+        encoded_resource_id = URI.encode_www_form_component(resource_id)
+        client.get("#{BASE_PATH}/#{deployment_id}/resourcedata/#{encoded_resource_id}")
+      end
+    end
+  end
+end

data/lib/flowable/resources/executions.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Flowable
+  module Resources
+    class Executions < Base
+      BASE_PATH = 'service/runtime/executions'
+
+      # List all executions
+      # @param options [Hash] Query parameters
+      # @option options [String] :id Filter by execution ID
+      # @option options [String] :processDefinitionKey Filter by process definition key
+      # @option options [String] :processDefinitionId Filter by process definition ID
+      # @option options [String] :processInstanceId Filter by process instance ID
+      # @option options [String] :activityId Filter by activity ID
+      # @option options [String] :parentId Filter by parent execution ID
+      # @option options [String] :tenantId Filter by tenant
+      # @return [Hash] Paginated list of executions
+      def list(**options)
+        params = paginate_params(options)
+        %i[id processDefinitionKey processDefinitionId processInstanceId
+           activityId parentId signalEventSubscriptionName
+           messageEventSubscriptionName tenantId tenantIdLike].each do |key|
+          params[key] = options[key] if options[key]
+        end
+        params[:withoutTenantId] = options[:withoutTenantId] if options.key?(:withoutTenantId)
+
+        client.get(BASE_PATH, params)
+      end
+
+      # Get a specific execution
+      # @param execution_id [String] The execution ID
+      # @return [Hash] Execution details
+      def get(execution_id)
+        client.get("#{BASE_PATH}/#{execution_id}")
+      end
+
+      # Execute an action on an execution
+      # @param execution_id [String] The execution ID
+      # @param action [String] Action type
+      # @param options [Hash] Additional action parameters
+      # @return [Hash] Response
+      def execute_action(execution_id, action, **options)
+        body = { action: action }
+        body.merge!(options)
+        client.put("#{BASE_PATH}/#{execution_id}", body)
+      end
+
+      # Signal an execution
+      # @param execution_id [String] The execution ID
+      # @param variables [Hash] Optional variables
+      # @return [Hash] Response
+      def signal(execution_id, variables: {})
+        body = { action: 'signal' }
+        body[:variables] = build_variables_array(variables) unless variables.empty?
+        client.put("#{BASE_PATH}/#{execution_id}", body)
+      end
+
+      # Trigger a message event
+      # @param execution_id [String] The execution ID
+      # @param message_name [String] The message name
+      # @param variables [Hash] Optional variables
+      # @return [Hash] Response
+      def message_event(execution_id, message_name, variables: {})
+        body = { action: 'messageEventReceived', messageName: message_name }
+        body[:variables] = build_variables_array(variables) unless variables.empty?
+        client.put("#{BASE_PATH}/#{execution_id}", body)
+      end
+
+      # Trigger a signal event
+      # @param execution_id [String] The execution ID
+      # @param signal_name [String] The signal name
+      # @param variables [Hash] Optional variables
+      # @return [Hash] Response
+      def signal_event(execution_id, signal_name, variables: {})
+        body = { action: 'signalEventReceived', signalName: signal_name }
+        body[:variables] = build_variables_array(variables) unless variables.empty?
+        client.put("#{BASE_PATH}/#{execution_id}", body)
+      end
+
+      # --- Variables ---
+
+      # Get all variables for an execution
+      # @param execution_id [String] The execution ID
+      # @param scope [String] 'local' or 'global'
+      # @return [Array<Hash>] List of variables
+      def variables(execution_id, scope: nil)
+        params = {}
+        params[:scope] = scope if scope
+        client.get("#{BASE_PATH}/#{execution_id}/variables", params)
+      end
+
+      # Get a specific variable from an execution
+      # @param execution_id [String] The execution ID
+      # @param variable_name [String] The variable name
+      # @param scope [String] 'local' or 'global'
+      # @return [Hash] Variable details
+      def variable(execution_id, variable_name, scope: nil)
+        params = {}
+        params[:scope] = scope if scope
+        client.get("#{BASE_PATH}/#{execution_id}/variables/#{variable_name}", params)
+      end
+
+      # Create variables on an execution
+      # @param execution_id [String] The execution ID
+      # @param variables [Hash] Variables to create (name => value)
+      # @return [Array<Hash>] Created variables
+      def create_variables(execution_id, variables)
+        client.post("#{BASE_PATH}/#{execution_id}/variables", build_variables_array(variables))
+      end
+
+      # Update variables on an execution
+      # @param execution_id [String] The execution ID
+      # @param variables [Hash] Variables to update (name => value)
+      # @return [Array<Hash>] Updated variables
+      def update_variables(execution_id, variables)
+        client.put("#{BASE_PATH}/#{execution_id}/variables", build_variables_array(variables))
+      end
+
+      # Query executions with complex filters
+      # @param query [Hash] Query body
+      # @return [Hash] Paginated list of executions
+      def query(query)
+        client.post('service/query/executions', query)
+      end
+
+      # Get active activities in an execution
+      # @param execution_id [String] The execution ID
+      # @return [Array<Hash>] List of activities
+      def activities(execution_id)
+        client.get("#{BASE_PATH}/#{execution_id}/activities")
+      end
+    end
+  end
+end