operaton-bpm-client 0.1.0

data/lib/operaton/bpm/client/task/impl/dto/set_variables_request_dto.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../../../impl/request_dto"
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        module Impl
+          module Dto
+            # Mirrors org.operaton.bpm.client.task.impl.dto.SetVariablesRequestDto
+            class SetVariablesRequestDto < Client::Impl::RequestDto
+              attr_reader :modifications
+
+              def initialize(worker_id, modifications)
+                super(worker_id)
+                @modifications = modifications
+              end
+
+              def as_json
+                super.merge("modifications" => modifications&.transform_values(&:as_json))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/task/impl/external_task_impl.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "../external_task"
+require_relative "../../variable/impl/typed_value_field"
+require_relative "../../../engine/variable/variable_map"
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        module Impl
+          # Mirrors org.operaton.bpm.client.task.impl.ExternalTaskImpl
+          class ExternalTaskImpl
+            include ExternalTask
+
+            attr_accessor :activity_id, :activity_instance_id, :error_message, :error_details,
+                          :execution_id, :id, :lock_expiration_time, :create_time,
+                          :process_definition_id, :process_definition_key,
+                          :process_definition_version_tag, :process_instance_id, :retries,
+                          :worker_id, :topic_name, :tenant_id, :priority, :variables,
+                          :business_key, :received_variable_map
+
+            def self.from_json(hash, object_mapper)
+              task = new
+              task.activity_id = hash["activityId"]
+              task.activity_instance_id = hash["activityInstanceId"]
+              task.error_message = hash["errorMessage"]
+              task.error_details = hash["errorDetails"]
+              task.execution_id = hash["executionId"]
+              task.id = hash["id"]
+              task.lock_expiration_time = parse_time(hash["lockExpirationTime"], object_mapper)
+              task.create_time = parse_time(hash["createTime"], object_mapper)
+              task.process_definition_id = hash["processDefinitionId"]
+              task.process_definition_key = hash["processDefinitionKey"]
+              task.process_definition_version_tag = hash["processDefinitionVersionTag"]
+              task.process_instance_id = hash["processInstanceId"]
+              task.retries = hash["retries"]
+              task.worker_id = hash["workerId"]
+              task.topic_name = hash["topicName"]
+              task.tenant_id = hash["tenantId"]
+              task.priority = hash["priority"] || 0
+              task.business_key = hash["businessKey"]
+              task.variables = (hash["variables"] || {}).transform_values do |field|
+                Variable::Impl::TypedValueField.from_json(field)
+              end
+              task.set_extension_properties(hash["extensionProperties"])
+              task
+            end
+
+            def self.parse_time(value, object_mapper)
+              return nil if value.nil?
+
+              object_mapper.parse_date(value)
+            end
+            private_class_method :parse_time
+
+            def initialize
+              @variables = {}
+              @received_variable_map = {}
+              @extension_properties = nil
+              @priority = 0
+            end
+
+            # Mirrors getAllVariables
+            def all_variables
+              received_variable_map.keys.to_h { |name| [name, variable(name)] }
+            end
+
+            # Mirrors getVariable
+            def variable(variable_name)
+              variable_value = received_variable_map[variable_name]
+              variable_value&.value
+            end
+
+            # Mirrors getAllVariablesTyped
+            def all_variables_typed(deserialize_object_values = true)
+              vars = Engine::Variable::VariableMap.new
+              received_variable_map.each_key do |variable_name|
+                vars.put_value_typed(variable_name, variable_typed(variable_name, deserialize_object_values))
+              end
+              vars
+            end
+
+            # Mirrors getVariableTyped
+            def variable_typed(variable_name, deserialize_object_values = true)
+              variable_value = received_variable_map[variable_name]
+              variable_value&.typed_value(deserialize_object_values)
+            end
+
+            def extension_properties
+              @extension_properties || {}
+            end
+
+            def set_extension_properties(extension_properties) # rubocop:disable Naming/AccessorMethodName
+              @extension_properties = extension_properties
+            end
+
+            def extension_property(property_key)
+              @extension_properties&.[](property_key)
+            end
+
+            def to_s
+              "ExternalTaskImpl [" \
+                "activityId=#{activity_id}, " \
+                "activityInstanceId=#{activity_instance_id}, " \
+                "businessKey=#{business_key}, " \
+                "errorDetails=#{error_details}, " \
+                "errorMessage=#{error_message}, " \
+                "executionId=#{execution_id}, " \
+                "id=#{id}, " \
+                "lockExpirationTime=#{lock_expiration_time}, " \
+                "createTime=#{create_time}, " \
+                "priority=#{priority}, " \
+                "processDefinitionId=#{process_definition_id}, " \
+                "processDefinitionKey=#{process_definition_key}, " \
+                "processDefinitionVersionTag=#{process_definition_version_tag}, " \
+                "processInstanceId=#{process_instance_id}, " \
+                "retries=#{retries}, " \
+                "tenantId=#{tenant_id}, " \
+                "topicName=#{topic_name}, " \
+                "workerId=#{worker_id}]"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/task/impl/external_task_service_impl.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "../external_task_service"
+require_relative "../../impl/engine_client_exception"
+require_relative "../../impl/external_task_client_logger"
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        module Impl
+          # Mirrors org.operaton.bpm.client.task.impl.ExternalTaskServiceImpl.
+          # Methods accept either an ExternalTask or an external task id where
+          # the Java interface declares overloads for both.
+          class ExternalTaskServiceImpl
+            include ExternalTaskService
+
+            def initialize(engine_client)
+              @engine_client = engine_client
+            end
+
+            def lock(task_or_id, lock_duration)
+              handling_errors("locking task") do
+                @engine_client.lock(task_id(task_or_id), lock_duration)
+              end
+            end
+
+            def unlock(external_task)
+              handling_errors("unlocking the external task") do
+                @engine_client.unlock(task_id(external_task))
+              end
+            end
+
+            def complete(task_or_id, variables = nil, local_variables = nil)
+              handling_errors("completing the external task") do
+                @engine_client.complete(task_id(task_or_id), variables, local_variables)
+              end
+            end
+
+            def set_variables(task_or_process_instance_id, variables)
+              process_instance_id =
+                if task_or_process_instance_id.respond_to?(:process_instance_id)
+                  task_or_process_instance_id.process_instance_id
+                else
+                  task_or_process_instance_id
+                end
+
+              handling_errors("setting variables for external task") do
+                @engine_client.set_variables(process_instance_id, variables)
+              end
+            end
+
+            def handle_failure(task_or_id, error_message, error_details, retries, retry_timeout,
+                               variables = nil, local_variables = nil)
+              handling_errors("notifying a failure") do
+                @engine_client.failure(task_id(task_or_id), error_message, error_details,
+                                       retries, retry_timeout, variables, local_variables)
+              end
+            end
+
+            def handle_bpmn_error(task_or_id, error_code, error_message = nil, variables = nil)
+              handling_errors("notifying a BPMN error") do
+                @engine_client.bpmn_error(task_id(task_or_id), error_code, error_message, variables)
+              end
+            end
+
+            def extend_lock(task_or_id, new_duration)
+              handling_errors("extending lock") do
+                @engine_client.extend_lock(task_id(task_or_id), new_duration)
+              end
+            end
+
+            protected
+
+            def task_id(task_or_id)
+              task_or_id.respond_to?(:id) ? task_or_id.id : task_or_id
+            end
+
+            def handling_errors(action_name)
+              yield
+            rescue Client::Impl::EngineClientException => e
+              raise Client::Impl::ExternalTaskClientLogger.client_logger
+                                                          .handled_engine_client_exception(action_name, e)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/task/ordering_config.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../impl/external_task_client_logger"
+require_relative "sorting_dto"
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        # Mirrors org.operaton.bpm.client.task.OrderingConfig
+        class OrderingConfig
+          module SortingField
+            CREATE_TIME = "createTime"
+          end
+
+          module Direction
+            ASC = "asc"
+            DESC = "desc"
+          end
+
+          attr_reader :ordering_properties
+
+          def initialize(ordering_properties)
+            @ordering_properties = ordering_properties
+          end
+
+          def self.empty
+            new([])
+          end
+
+          def configure_field(field)
+            ordering_properties << OrderingProperty.of(field, nil)
+          end
+
+          def configure_direction_on_last_field(direction)
+            last_configured_property = validate_and_get_last_configured_property
+            raise logger.double_direction_config_exception unless last_configured_property.direction.nil?
+
+            last_configured_property.direction = direction
+          end
+
+          def validate_ordering_properties
+            raise logger.missing_direction_exception if ordering_properties.any? { |p| p.direction.nil? }
+          end
+
+          def to_sorting_dtos
+            ordering_properties.map { |property| SortingDto.from_ordering_property(property) }
+          end
+
+          protected
+
+          def validate_and_get_last_configured_property
+            last_configured_property = ordering_properties.last
+            raise logger.unspecified_order_by_method_exception if last_configured_property.nil?
+
+            last_configured_property
+          end
+
+          def logger
+            Client::Impl::ExternalTaskClientLogger.client_logger
+          end
+
+          # Mirrors OrderingConfig.OrderingProperty
+          class OrderingProperty
+            attr_accessor :field, :direction
+
+            def self.of(field, direction)
+              property = new
+              property.field = field
+              property.direction = direction
+              property
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/task/sorting_dto.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        # Mirrors org.operaton.bpm.client.task.SortingDto
+        class SortingDto
+          attr_accessor :sort_by, :sort_order
+
+          def self.of(sort_by, sort_order)
+            dto = new
+            dto.sort_by = sort_by
+            dto.sort_order = sort_order
+            dto
+          end
+
+          def self.from_ordering_property(property)
+            of(property.field, property.direction)
+          end
+
+          def as_json
+            { "sortBy" => sort_by, "sortOrder" => sort_order }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/topic/impl/dto/fetch_and_lock_request_dto.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../../../impl/request_dto"
+require_relative "../../../task/ordering_config"
+
+module Operaton
+  module Bpm
+    module Client
+      module Topic
+        module Impl
+          module Dto
+            # Mirrors org.operaton.bpm.client.topic.impl.dto.FetchAndLockRequestDto
+            # (annotated @JsonInclude(NON_NULL) in Java — nil fields are omitted).
+            class FetchAndLockRequestDto < Client::Impl::RequestDto
+              attr_reader :max_tasks, :async_response_timeout, :topics, :sorting
+
+              def initialize(worker_id, max_tasks, async_response_timeout, topics,
+                             use_priority = true, ordering_config = Task::OrderingConfig.empty)
+                super(worker_id)
+                @max_tasks = max_tasks
+                @use_priority = use_priority
+                @async_response_timeout = async_response_timeout
+                @topics = topics
+                @sorting = ordering_config.to_sorting_dtos
+              end
+
+              def use_priority?
+                @use_priority
+              end
+
+              def as_json
+                json = super.merge(
+                  "maxTasks" => max_tasks,
+                  "usePriority" => use_priority?,
+                  "asyncResponseTimeout" => async_response_timeout,
+                  "topics" => topics.map(&:as_json),
+                  "sorting" => sorting.map(&:as_json)
+                )
+                json.compact
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/topic/impl/dto/fetch_and_lock_response_dto.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Client
+      module Topic
+        module Impl
+          module Dto
+            # Mirrors org.operaton.bpm.client.topic.impl.dto.FetchAndLockResponseDto
+            class FetchAndLockResponseDto
+              attr_reader :external_tasks, :error
+
+              def initialize(external_tasks_or_error)
+                if external_tasks_or_error.is_a?(::Exception)
+                  @external_tasks = []
+                  @error = external_tasks_or_error
+                else
+                  @external_tasks = external_tasks_or_error
+                  @error = nil
+                end
+              end
+
+              def error?
+                !error.nil?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/topic/impl/dto/topic_request_dto.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Client
+      module Topic
+        module Impl
+          module Dto
+            # Mirrors org.operaton.bpm.client.topic.impl.dto.TopicRequestDto
+            class TopicRequestDto
+              attr_reader :topic_name, :lock_duration, :variables, :business_key
+              attr_accessor :local_variables, :process_definition_id, :process_definition_id_in,
+                            :process_definition_key, :process_definition_key_in,
+                            :process_definition_version_tag, :process_variables,
+                            :without_tenant_id, :tenant_id_in, :include_extension_properties
+
+              def initialize(topic_name, lock_duration, variables, business_key)
+                @topic_name = topic_name
+                @lock_duration = lock_duration
+                @variables = variables
+                @business_key = business_key
+                @local_variables = false
+                @without_tenant_id = false
+                @include_extension_properties = false
+              end
+
+              def self.from_topic_subscription(topic_subscription, client_lock_duration)
+                lock_duration = topic_subscription.lock_duration || client_lock_duration
+
+                dto = new(topic_subscription.topic_name, lock_duration,
+                          topic_subscription.variable_names, topic_subscription.business_key)
+
+                dto.process_definition_id = topic_subscription.process_definition_id
+                dto.process_definition_id_in = topic_subscription.process_definition_id_in
+                dto.process_definition_key = topic_subscription.process_definition_key
+                dto.process_definition_key_in = topic_subscription.process_definition_key_in
+                dto.without_tenant_id = topic_subscription.without_tenant_id?
+                dto.tenant_id_in = topic_subscription.tenant_id_in
+                dto.process_definition_version_tag = topic_subscription.process_definition_version_tag
+                dto.process_variables = topic_subscription.process_variables
+                dto.local_variables = topic_subscription.local_variables?
+                dto.include_extension_properties = topic_subscription.include_extension_properties?
+                dto
+              end
+
+              def as_json
+                {
+                  "topicName" => topic_name,
+                  "lockDuration" => lock_duration,
+                  "variables" => variables,
+                  "localVariables" => local_variables,
+                  "businessKey" => business_key,
+                  "processDefinitionId" => process_definition_id,
+                  "processDefinitionIdIn" => process_definition_id_in,
+                  "processDefinitionKey" => process_definition_key,
+                  "processDefinitionKeyIn" => process_definition_key_in,
+                  "processDefinitionVersionTag" => process_definition_version_tag,
+                  "processVariables" => process_variables,
+                  "withoutTenantId" => without_tenant_id,
+                  "tenantIdIn" => tenant_id_in,
+                  "includeExtensionProperties" => include_extension_properties
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/topic/impl/topic_subscription_builder_impl.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative "../topic_subscription_builder"
+require_relative "topic_subscription_impl"
+require_relative "../../impl/external_task_client_logger"
+
+module Operaton
+  module Bpm
+    module Client
+      module Topic
+        module Impl
+          # Mirrors org.operaton.bpm.client.topic.impl.TopicSubscriptionBuilderImpl
+          class TopicSubscriptionBuilderImpl
+            include TopicSubscriptionBuilder
+
+            def initialize(topic_name, topic_subscription_manager)
+              @topic_name = topic_name
+              # if not nil, no variables are retrieved by default
+              @variable_names = nil
+              @lock_duration = nil
+              @topic_subscription_manager = topic_subscription_manager
+              @local_variables = false
+              @business_key = nil
+              @process_definition_id = nil
+              @process_definition_ids = nil
+              @process_definition_key = nil
+              @process_definition_keys = nil
+              @process_definition_version_tag = nil
+              @process_variables = nil
+              @without_tenant_id = false
+              @tenant_ids = nil
+              @external_task_handler = nil
+              @include_extension_properties = false
+            end
+
+            def lock_duration(lock_duration)
+              @lock_duration = lock_duration
+              self
+            end
+
+            # Accepts a handler object responding to #execute, any callable, or a block.
+            def handler(external_task_handler = nil, &block)
+              @external_task_handler = external_task_handler || block
+              self
+            end
+
+            def variables(*variable_names)
+              ensure_not_nil(variable_names, "variableNames")
+              @variable_names = variable_names.flatten
+              self
+            end
+
+            def local_variables(local_variables)
+              @local_variables = local_variables
+              self
+            end
+
+            def business_key(business_key)
+              @business_key = business_key
+              self
+            end
+
+            def process_definition_id(process_definition_id)
+              @process_definition_id = process_definition_id
+              self
+            end
+
+            def process_definition_id_in(*process_definition_ids)
+              ensure_not_nil(process_definition_ids, "processDefinitionIds")
+              @process_definition_ids = process_definition_ids.flatten
+              self
+            end
+
+            def process_definition_key(process_definition_key)
+              @process_definition_key = process_definition_key
+              self
+            end
+
+            def process_definition_key_in(*process_definition_keys)
+              ensure_not_nil(process_definition_keys, "processDefinitionKeys")
+              @process_definition_keys = process_definition_keys.flatten
+              self
+            end
+
+            def process_definition_version_tag(process_definition_version_tag)
+              ensure_not_nil(process_definition_version_tag, "processDefinitionVersionTag")
+              @process_definition_version_tag = process_definition_version_tag
+              self
+            end
+
+            def process_variables_equals_in(process_variables)
+              ensure_not_nil(process_variables, "processVariables")
+              @process_variables ||= {}
+              process_variables.each do |name, value|
+                ensure_not_nil(name, "processVariableName")
+                @process_variables[name] = value
+              end
+              self
+            end
+
+            def process_variable_equals(name, value)
+              ensure_not_nil(name, "processVariableName")
+              @process_variables ||= {}
+              @process_variables[name] = value
+              self
+            end
+
+            def without_tenant_id
+              @without_tenant_id = true
+              self
+            end
+
+            def tenant_id_in(*tenant_ids)
+              ensure_not_nil(tenant_ids, "tenantIds")
+              @tenant_ids = tenant_ids.flatten
+              self
+            end
+
+            def include_extension_properties(include_extension_properties)
+              @include_extension_properties = include_extension_properties
+              self
+            end
+
+            def open
+              raise logger.topic_name_null_exception if @topic_name.nil?
+
+              if !@lock_duration.nil? && @lock_duration <= 0
+                raise logger.lock_duration_is_not_greater_than_zero_exception(@lock_duration)
+              end
+
+              raise logger.external_task_handler_null_exception if @external_task_handler.nil?
+
+              subscription = TopicSubscriptionImpl.new(@topic_name, @lock_duration, @external_task_handler,
+                                                       @topic_subscription_manager, @variable_names, @business_key)
+              subscription.process_definition_id = @process_definition_id if @process_definition_id
+              subscription.process_definition_id_in = @process_definition_ids if @process_definition_ids
+              subscription.process_definition_key = @process_definition_key if @process_definition_key
+              subscription.process_definition_key_in = @process_definition_keys if @process_definition_keys
+              subscription.without_tenant_id = @without_tenant_id if @without_tenant_id
+              subscription.tenant_id_in = @tenant_ids if @tenant_ids
+              subscription.process_definition_version_tag = @process_definition_version_tag if @process_definition_version_tag
+              subscription.process_variables = @process_variables if @process_variables
+              subscription.local_variables = @local_variables if @local_variables
+              subscription.include_extension_properties = @include_extension_properties if @include_extension_properties
+
+              @topic_subscription_manager.subscribe(subscription)
+              subscription
+            end
+
+            protected
+
+            def ensure_not_nil(parameter, parameter_name)
+              raise logger.pass_null_value_parameter(parameter_name) if parameter.nil?
+            end
+
+            def logger
+              Client::Impl::ExternalTaskClientLogger.client_logger
+            end
+          end
+        end
+      end
+    end
+  end
+end