operaton-bpm-client 0.1.0

data/lib/operaton/bpm/client/variable/impl/mapper/boolean_value_mapper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "primitive_value_mapper"
+require_relative "../../../../engine/variable/variables"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.BooleanValueMapper
+            class BooleanValueMapper < PrimitiveValueMapper
+              def initialize
+                super(Engine::Variable::ValueType::BOOLEAN)
+              end
+
+              def convert_to_typed_value(untyped_value)
+                Engine::Variable::Variables.boolean_value(untyped_value.value)
+              end
+
+              def read_typed_value(typed_value_field)
+                Engine::Variable::Variables.boolean_value(typed_value_field.value)
+              end
+
+              def write_value(boolean_value, typed_value_field)
+                typed_value_field.value = boolean_value.value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/variable/impl/mapper/byte_array_value_mapper.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "base64"
+require_relative "primitive_value_mapper"
+require_relative "../../../../engine/variable/variables"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.ByteArrayValueMapper
+            class ByteArrayValueMapper < PrimitiveValueMapper
+              def initialize
+                super(Engine::Variable::ValueType::BYTES)
+              end
+
+              def convert_to_typed_value(untyped_value)
+                value = untyped_value.value
+                byte_arr = value.respond_to?(:read) ? value.read : value
+                Engine::Variable::Variables.byte_array_value(byte_arr)
+              end
+
+              def read_typed_value(typed_value_field)
+                byte_arr = nil
+                value = typed_value_field.value
+                byte_arr = Base64.decode64(value) unless value.nil?
+                Engine::Variable::Variables.byte_array_value(byte_arr)
+              end
+
+              def write_value(bytes_value, typed_value_field)
+                bytes = bytes_value.value
+                typed_value_field.value = Base64.strict_encode64(bytes) unless bytes.nil?
+              end
+
+              protected
+
+              def can_write_value(typed_value)
+                super || typed_value.value.respond_to?(:read)
+              end
+
+              def can_read_value(typed_value_field)
+                value = typed_value_field.value
+                value.nil? || value.is_a?(String)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/variable/impl/mapper/date_value_mapper.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "primitive_value_mapper"
+require_relative "../../../../engine/variable/variables"
+require_relative "../../../impl/external_task_client_logger"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.DateValueMapper.
+            # The date format is a Ruby strftime pattern.
+            class DateValueMapper < PrimitiveValueMapper
+              def initialize(date_format)
+                super(Engine::Variable::ValueType::DATE)
+                @date_format = date_format
+              end
+
+              def convert_to_typed_value(untyped_value)
+                Engine::Variable::Variables.date_value(to_time(untyped_value.value))
+              end
+
+              def read_typed_value(typed_value_field)
+                date = nil
+                value = typed_value_field.value
+                unless value.nil?
+                  begin
+                    date = Time.strptime(value, @date_format)
+                  rescue ArgumentError => e
+                    raise Client::Impl::ExternalTaskClientLogger.client_logger
+                                                                .value_mapper_exception_while_parsing_date(value, e)
+                  end
+                end
+                Engine::Variable::Variables.date_value(date)
+              end
+
+              def write_value(date_value, typed_value_field)
+                date = date_value.value
+                typed_value_field.value = to_time(date).strftime(@date_format) unless date.nil?
+              end
+
+              protected
+
+              def can_read_value(typed_value_field)
+                value = typed_value_field.value
+                value.nil? || value.is_a?(String)
+              end
+
+              def to_time(value)
+                value.is_a?(Time) ? value : value.to_time
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/variable/impl/mapper/double_value_mapper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "number_value_mapper"
+require_relative "../../../../engine/variable/variables"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.DoubleValueMapper
+            class DoubleValueMapper < NumberValueMapper
+              def initialize
+                super(Engine::Variable::ValueType::DOUBLE)
+              end
+
+              def convert_to_typed_value(untyped_value)
+                Engine::Variable::Variables.double_value(untyped_value.value)
+              end
+
+              def write_value(double_value, typed_value_field)
+                typed_value_field.value = double_value.value
+              end
+
+              def read_typed_value(typed_value_field)
+                value = typed_value_field.value
+                Engine::Variable::Variables.double_value(value.nil? ? nil : Float(value))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/variable/impl/mapper/file_value_mapper.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "base64"
+require_relative "../abstract_typed_value_mapper"
+require_relative "../value/deferred_file_value_impl"
+require_relative "../../../../engine/variable/typed_value"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.FileValueMapper
+            class FileValueMapper < AbstractTypedValueMapper
+              VALUE_INFO_FILE_NAME = Engine::Variable::FileValueType::VALUE_INFO_FILE_NAME
+              VALUE_INFO_FILE_MIME_TYPE = Engine::Variable::FileValueType::VALUE_INFO_FILE_MIME_TYPE
+              VALUE_INFO_FILE_ENCODING = Engine::Variable::FileValueType::VALUE_INFO_FILE_ENCODING
+
+              def initialize(engine_client)
+                super(Engine::Variable::ValueType::FILE)
+                @engine_client = engine_client
+              end
+
+              def convert_to_typed_value(_untyped_value)
+                raise NotImplementedError, "Currently no automatic conversation from UntypedValue to FileValue"
+              end
+
+              def read_value(typed_value_field, _deserialize_value = true)
+                value_info = typed_value_field.value_info || {}
+                filename = value_info[VALUE_INFO_FILE_NAME]
+
+                file_value = Value::DeferredFileValueImpl.new(filename, @engine_client)
+                mime_type = value_info[VALUE_INFO_FILE_MIME_TYPE]
+                file_value.mime_type = mime_type if mime_type
+                encoding = value_info[VALUE_INFO_FILE_ENCODING]
+                file_value.encoding = encoding if encoding
+                file_value
+              end
+
+              def write_value(file_value, typed_value_field)
+                value_info = { VALUE_INFO_FILE_NAME => file_value.filename }
+                value_info[VALUE_INFO_FILE_ENCODING] = file_value.encoding if file_value.encoding
+                value_info[VALUE_INFO_FILE_MIME_TYPE] = file_value.mime_type if file_value.mime_type
+                typed_value_field.value_info = value_info
+
+                bytes = file_value.byte_array
+                typed_value_field.value = Base64.strict_encode64(bytes) unless bytes.nil?
+              end
+
+              protected
+
+              def can_write_value(typed_value)
+                return false if typed_value.nil? || typed_value.type.nil? # untyped value
+
+                typed_value.type.name == value_type.name && !deferred?(typed_value)
+              end
+
+              def can_read_value(typed_value_field)
+                value = typed_value_field.value
+                value.nil? || value.is_a?(String)
+              end
+
+              def deferred?(variable_value)
+                variable_value.is_a?(Variable::Value::DeferredFileValue) && !variable_value.loaded?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/variable/impl/mapper/integer_value_mapper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "number_value_mapper"
+require_relative "../../../../engine/variable/variables"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.IntegerValueMapper
+            class IntegerValueMapper < NumberValueMapper
+              def initialize
+                super(Engine::Variable::ValueType::INTEGER)
+              end
+
+              def convert_to_typed_value(untyped_value)
+                Engine::Variable::Variables.integer_value(untyped_value.value)
+              end
+
+              def write_value(int_value, typed_value_field)
+                typed_value_field.value = int_value.value
+              end
+
+              def read_typed_value(typed_value_field)
+                value = typed_value_field.value
+                Engine::Variable::Variables.integer_value(value.nil? ? nil : Integer(value))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/variable/impl/mapper/json_value_mapper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "primitive_value_mapper"
+require_relative "../../client_values"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.JsonValueMapper
+            class JsonValueMapper < PrimitiveValueMapper
+              def initialize
+                super(ClientValues::JSON)
+              end
+
+              def convert_to_typed_value(untyped_value)
+                ClientValues.json_value(untyped_value.value)
+              end
+
+              def write_value(json_value, typed_value_field)
+                typed_value_field.value = json_value.value
+              end
+
+              def read_typed_value(typed_value_field)
+                ClientValues.json_value(typed_value_field.value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/variable/impl/mapper/long_value_mapper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "number_value_mapper"
+require_relative "../../../../engine/variable/variables"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.LongValueMapper
+            class LongValueMapper < NumberValueMapper
+              def initialize
+                super(Engine::Variable::ValueType::LONG)
+              end
+
+              def convert_to_typed_value(untyped_value)
+                Engine::Variable::Variables.long_value(untyped_value.value)
+              end
+
+              def write_value(long_value, typed_value_field)
+                typed_value_field.value = long_value.value
+              end
+
+              def read_typed_value(typed_value_field)
+                value = typed_value_field.value
+                Engine::Variable::Variables.long_value(value.nil? ? nil : Integer(value))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/variable/impl/mapper/null_value_mapper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_typed_value_mapper"
+require_relative "../../../../engine/variable/typed_value"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.NullValueMapper
+            class NullValueMapper < AbstractTypedValueMapper
+              def initialize
+                super(Engine::Variable::ValueType::NULL)
+              end
+
+              def convert_to_typed_value(_untyped_value)
+                Engine::Variable::NullValue::INSTANCE
+              end
+
+              def write_value(_typed_value, typed_value_field)
+                typed_value_field.value = nil
+              end
+
+              def read_value(_typed_value_field, _deserialize = true)
+                Engine::Variable::NullValue::INSTANCE
+              end
+
+              protected
+
+              def can_write_value(typed_value)
+                typed_value.value.nil?
+              end
+
+              def can_read_value(typed_value_field)
+                typed_value_field.value.nil?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/variable/impl/mapper/number_value_mapper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "primitive_value_mapper"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.NumberValueMapper
+            class NumberValueMapper < PrimitiveValueMapper
+              protected
+
+              def can_read_value(typed_value_field)
+                value = typed_value_field.value
+                value.nil? || value.is_a?(Numeric)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/variable/impl/mapper/object_value_mapper.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_typed_value_mapper"
+require_relative "../../../../engine/variable/typed_value"
+require_relative "../../../impl/external_task_client_logger"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.ObjectValueMapper
+            class ObjectValueMapper < AbstractTypedValueMapper
+              VALUE_INFO_OBJECT_TYPE_NAME =
+                Engine::Variable::ObjectValueType::VALUE_INFO_OBJECT_TYPE_NAME
+              VALUE_INFO_SERIALIZATION_DATA_FORMAT =
+                Engine::Variable::ObjectValueType::VALUE_INFO_SERIALIZATION_DATA_FORMAT
+
+              attr_reader :data_format
+
+              def initialize(serialization_data_format, data_format)
+                super(Engine::Variable::ValueType::OBJECT)
+                @serialization_data_format = serialization_data_format
+                @data_format = data_format
+              end
+
+              def serialization_dataformat
+                @serialization_data_format
+              end
+
+              def convert_to_typed_value(untyped_value)
+                Engine::Variable::Variables.object_value(untyped_value.value).create
+              end
+
+              def write_value(typed_value, typed_value_field)
+                serialized_string_value = typed_value.value_serialized
+
+                if typed_value.deserialized?
+                  object_to_serialize = typed_value.instance_variable_get(:@value)
+                  unless object_to_serialize.nil?
+                    begin
+                      serialized_string_value = data_format.write_value(object_to_serialize)
+                    rescue StandardError => e
+                      raise logger.value_mapper_exception_while_serializing_object(e)
+                    end
+                  end
+                end
+
+                typed_value_field.value = serialized_string_value
+                update_typed_value(typed_value, serialized_string_value)
+              end
+
+              def read_value(typed_value_field, deserialize_object_value)
+                serialized_string_value = typed_value_field.value
+
+                if deserialize_object_value
+                  deserialized_object = nil
+                  unless serialized_string_value.nil?
+                    begin
+                      object_type_name = read_object_name_from_fields(typed_value_field)
+                      deserialized_object = data_format.read_value(serialized_string_value, object_type_name)
+                    rescue StandardError => e
+                      raise logger.value_mapper_exception_while_deserializing_object(e)
+                    end
+                  end
+                  create_deserialized_value(deserialized_object, serialized_string_value, typed_value_field)
+                else
+                  create_serialized_value(serialized_string_value, typed_value_field)
+                end
+              end
+
+              protected
+
+              def update_typed_value(value, serialized_value)
+                object_type_name = object_type_name_for(value)
+                value.object_type_name = object_type_name
+                value.serialized_value = serialized_value
+                value.serialization_data_format = @serialization_data_format
+              end
+
+              def object_type_name_for(value)
+                object_type_name = value.object_type_name
+
+                if object_type_name.nil? && !value.deserialized? && !value.value_serialized.nil?
+                  raise logger.value_mapper_exception_due_to_no_object_type_name
+                end
+
+                if value.deserialized? && !value.instance_variable_get(:@value).nil?
+                  object_type_name = data_format.canonical_type_name(value.instance_variable_get(:@value))
+                end
+
+                object_type_name
+              end
+
+              def can_write_value(typed_value)
+                is_serializable = typed_value.is_a?(Engine::Variable::ObjectValue)
+                is_untyped = typed_value.is_a?(Engine::Variable::UntypedValue)
+                return false unless is_serializable || is_untyped
+
+                if is_serializable
+                  requested_data_format = typed_value.serialization_data_format
+
+                  if typed_value.deserialized?
+                    raw_value = typed_value.instance_variable_get(:@value)
+                    can_serialize = raw_value.nil? || data_format.can_map(raw_value)
+                    can_serialize && (requested_data_format.nil? ||
+                                      @serialization_data_format == requested_data_format)
+                  else
+                    # serialized object => dataformat must match
+                    @serialization_data_format == requested_data_format
+                  end
+                else
+                  typed_value.value.nil? || data_format.can_map(typed_value.value)
+                end
+              end
+
+              def can_read_value(typed_value_field)
+                value_info = typed_value_field.value_info || {}
+                serialization_dataformat_of_field = value_info[VALUE_INFO_SERIALIZATION_DATA_FORMAT]
+                value = typed_value_field.value
+                (value.nil? || value.is_a?(String)) &&
+                  serialization_dataformat == serialization_dataformat_of_field
+              end
+
+              def create_deserialized_value(deserialized_object, serialized_value, typed_value_field)
+                object_type_name = read_object_name_from_fields(typed_value_field)
+                Engine::Variable::ObjectValue.new(deserialized_object, serialized_value,
+                                                  @serialization_data_format, object_type_name, true)
+              end
+
+              def create_serialized_value(serialized_value, typed_value_field)
+                object_type_name = read_object_name_from_fields(typed_value_field)
+                Engine::Variable::ObjectValue.new(nil, serialized_value,
+                                                  @serialization_data_format, object_type_name, false)
+              end
+
+              def read_object_name_from_fields(typed_value_field)
+                (typed_value_field.value_info || {})[VALUE_INFO_OBJECT_TYPE_NAME]
+              end
+
+              def logger
+                Client::Impl::ExternalTaskClientLogger.client_logger
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/variable/impl/mapper/primitive_value_mapper.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../abstract_typed_value_mapper"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.PrimitiveValueMapper
+            class PrimitiveValueMapper < AbstractTypedValueMapper
+              def read_value(typed_value_field, _deserialize_object_value = true)
+                read_typed_value(typed_value_field)
+              end
+
+              # Subclasses implement the single-argument variant, mirroring the
+              # Java abstract readValue(TypedValueField).
+              def read_typed_value(typed_value_field)
+                raise NotImplementedError
+              end
+
+              protected
+
+              def assignable?(value)
+                value_type.assignable?(value)
+              end
+
+              def can_write_value(typed_value)
+                value = typed_value.value
+                value.nil? || assignable?(value)
+              end
+
+              def can_read_value(typed_value_field)
+                value = typed_value_field.value
+                value.nil? || assignable?(value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/variable/impl/mapper/short_value_mapper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "number_value_mapper"
+require_relative "../../../../engine/variable/variables"
+
+module Operaton
+  module Bpm
+    module Client
+      module Variable
+        module Impl
+          module Mapper
+            # Mirrors org.operaton.bpm.client.variable.impl.mapper.ShortValueMapper
+            class ShortValueMapper < NumberValueMapper
+              def initialize
+                super(Engine::Variable::ValueType::SHORT)
+              end
+
+              def convert_to_typed_value(untyped_value)
+                Engine::Variable::Variables.short_value(untyped_value.value)
+              end
+
+              def write_value(short_value, typed_value_field)
+                typed_value_field.value = short_value.value
+              end
+
+              def read_typed_value(typed_value_field)
+                value = typed_value_field.value
+                Engine::Variable::Variables.short_value(value.nil? ? nil : Integer(value))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end