apimatic_core 0.2.2 → 0.3.0

data/lib/apimatic-core/utilities/date_time_helper.rb

@@ -17,7 +17,7 @@ module CoreLibrary
       hash[key] = {}
       date_time.each do |k, v|
         hash[key][k] =
-          v.is_a?(DateTime) ? DateTimeHelper.to_rfc1123(v) : v
+          v.instance_of?(DateTime) ? DateTimeHelper.to_rfc1123(v) : v
       end
       hash[key]
     end
@@ -29,13 +29,13 @@ module CoreLibrary
       return if date_time.nil?
 
       hash[key] = date_time.map do |v|
-        v.is_a?(DateTime) ? DateTimeHelper.to_rfc1123(v) : v
+        v.instance_of?(DateTime) ? DateTimeHelper.to_rfc1123(v) : v
       end
     end
 
     # Safely converts a DateTime object into a unix format string.
     # @param [DateTime] date_time The DateTime object.
-    # @return [String] The unix formatted datetime string.
+    # @return [Integer] The unix formatted datetime integer.
     def self.to_unix(date_time)
       date_time.to_time.utc.to_i unless date_time.nil?
     end
@@ -49,7 +49,7 @@ module CoreLibrary
       hash[key] = {}
       date_time.each do |k, v|
         hash[key][k] =
-          v.is_a?(DateTime) ? DateTimeHelper.to_unix(v) : v
+          v.instance_of?(DateTime) ? DateTimeHelper.to_unix(v) : v
       end
       hash[key]
     end
@@ -61,7 +61,7 @@ module CoreLibrary
       return if date_time.nil?
 
       hash[key] = date_time.map do |v|
-        v.is_a?(DateTime) ? DateTimeHelper.to_unix(v) : v
+        v.instance_of?(DateTime) ? DateTimeHelper.to_unix(v) : v
       end
     end
 
@@ -81,7 +81,7 @@ module CoreLibrary
       hash[key] = {}
       date_time.each do |k, v|
         hash[key][k] =
-          v.is_a?(DateTime) ? DateTimeHelper.to_rfc3339(v) : v
+          v.instance_of?(DateTime) ? DateTimeHelper.to_rfc3339(v) : v
       end
       hash[key]
     end
@@ -93,7 +93,7 @@ module CoreLibrary
       return if date_time.nil?
 
       hash[key] = date_time.map do |v|
-        v.is_a?(DateTime) ? DateTimeHelper.to_rfc3339(v) : v
+        v.instance_of?(DateTime) ? DateTimeHelper.to_rfc3339(v) : v
       end
     end
 
@@ -122,5 +122,52 @@ module CoreLibrary
         DateTime.rfc3339("#{date_time}Z")
       end
     end
+
+    def self.valid_datetime?(dt_format, dt)
+      case dt_format
+      when DateTimeFormat::HTTP_DATE_TIME
+        return DateTimeHelper.rfc_1123?(dt)
+      when DateTimeFormat::RFC3339_DATE_TIME
+        return DateTimeHelper.rfc_3339?(dt)
+      when DateTimeFormat::UNIX_DATE_TIME
+        return DateTimeHelper.unix_timestamp?(dt)
+      end
+
+      false
+    end
+
+    def self.valid_date?(date_value)
+      if date_value.instance_of?(Date)
+        true
+      elsif date_value.instance_of?(String) && date_value.match?(/^\d{4}-\d{2}-\d{2}$/)
+        DateTime.strptime(date_value, '%Y-%m-%d')
+        true
+      else
+        false
+      end
+    rescue ArgumentError
+      false
+    end
+
+    def self.rfc_1123?(datetime_value)
+      DateTime.strptime(datetime_value, '%a, %d %b %Y %H:%M:%S %Z')
+      true
+    rescue ArgumentError, TypeError
+      false
+    end
+
+    def self.rfc_3339?(datetime_value)
+      DateTime.strptime(datetime_value, '%Y-%m-%dT%H:%M:%S')
+      true
+    rescue ArgumentError, TypeError
+      false
+    end
+
+    def self.unix_timestamp?(timestamp)
+      Time.at(Float(timestamp))
+      true
+    rescue ArgumentError, TypeError
+      false
+    end
   end
 end

data/lib/apimatic-core/utilities/union_type_helper.rb

@@ -0,0 +1,298 @@
+module CoreLibrary
+  # Helper methods for handling union types.
+  class UnionTypeHelper
+    NONE_MATCHED_ERROR_MESSAGE = 'We could not match any acceptable types against the given JSON.'.freeze
+    MORE_THAN_1_MATCHED_ERROR_MESSAGE = 'There are more than one acceptable type matched against the given JSON.'.freeze
+
+    def self.validate_array_of_dict_case(union_types, array_value, is_for_one_of)
+      return [false, []] if invalid_array_value?(array_value)
+
+      collection_cases = []
+      valid_cases = []
+      array_value.each do |item|
+        case_validity, inner_dictionary = validate_dict_case(union_types, item, is_for_one_of)
+        collection_cases << inner_dictionary
+        valid_cases << case_validity
+      end
+      is_valid = valid_cases.count(true) == array_value.size
+      [is_valid, collection_cases]
+    end
+
+    def self.validate_dict_of_array_case(union_types, dict_value, is_for_one_of)
+      return [false, []] if invalid_dict_value?(dict_value)
+
+      collection_cases = {}
+      valid_cases = []
+      dict_value.each do |key, item|
+        case_validity, inner_array = validate_array_case(union_types, item, is_for_one_of)
+        collection_cases[key] = inner_array
+        valid_cases << case_validity
+      end
+      is_valid = valid_cases.count(true) == dict_value.size
+      [is_valid, collection_cases]
+    end
+
+    def self.validate_dict_case(union_types, dict_value, is_for_one_of)
+      return [false, []] if invalid_dict_value?(dict_value)
+
+      is_valid, collection_cases = process_dict_items(union_types, dict_value, is_for_one_of)
+
+      [is_valid, collection_cases]
+    end
+
+    def self.process_dict_items(union_types, dict_value, is_for_one_of)
+      is_valid = true
+      collection_cases = {}
+
+      dict_value.each do |key, value|
+        union_type_cases = make_deep_copies(union_types)
+        matched_count = get_matched_count(value, union_type_cases, is_for_one_of)
+        is_valid = check_item_validity(is_for_one_of, is_valid, matched_count)
+        collection_cases[key] = union_type_cases
+      end
+
+      [is_valid, collection_cases]
+    end
+
+    def self.validate_array_case(union_types, array_value, is_for_one_of)
+      return [false, []] if invalid_array_value?(array_value)
+
+      is_valid, collection_cases = process_array_items(union_types, array_value, is_for_one_of)
+
+      [is_valid, collection_cases]
+    end
+
+    def self.process_array_items(union_types, array_value, is_for_one_of)
+      is_valid = true
+      collection_cases = []
+
+      array_value.each do |item|
+        union_type_cases = make_deep_copies(union_types)
+        matched_count = get_matched_count(item, union_type_cases, is_for_one_of)
+        is_valid = check_item_validity(is_for_one_of, is_valid, matched_count)
+        collection_cases << union_type_cases
+      end
+
+      [is_valid, collection_cases]
+    end
+
+    def self.check_item_validity(is_for_one_of, is_valid, matched_count)
+      if is_valid && is_for_one_of
+        is_valid = matched_count == 1
+      elsif is_valid
+        is_valid = matched_count >= 1
+      end
+      is_valid
+    end
+
+    def self.make_deep_copies(union_types)
+      nested_cases = []
+      union_types.each do |union_type|
+        nested_cases << union_type.dup
+      end
+      nested_cases
+    end
+
+    def self.get_matched_count(value, union_types, is_for_one_of)
+      matched_count = get_valid_cases_count(value, union_types)
+
+      if is_for_one_of && matched_count == 1
+        return matched_count
+      elsif !is_for_one_of && matched_count.positive?
+        return matched_count
+      end
+
+      matched_count = handle_discriminator_cases(value, union_types)
+      matched_count
+    end
+
+    def self.get_valid_cases_count(value, union_types)
+      union_types.count { |union_type| union_type.validate(value).is_valid }
+    end
+
+    def self.handle_discriminator_cases(value, union_types)
+      has_discriminator_cases = union_types.all? do |union_type|
+        union_type.union_type_context.discriminator && union_type.union_type_context.discriminator_value
+      end
+
+      if has_discriminator_cases
+        union_types.each do |union_type|
+          union_type.union_type_context.discriminator = nil
+          union_type.union_type_context.discriminator_value = nil
+        end
+
+        get_valid_cases_count(value, union_types)
+      else
+        0
+      end
+    end
+
+    def self.optional_or_nullable_case?(current_context, inner_contexts)
+      current_context.nullable_or_optional? || inner_contexts.any?(&:nullable_or_optional?)
+    end
+
+    def self.update_nested_flag_for_union_types(nested_union_types)
+      nested_union_types.each do |union_type|
+        union_type.union_type_context.is_nested = true
+      end
+    end
+
+    def self.invalid_array_value?(value)
+      value.nil? || !value.instance_of?(Array)
+    end
+
+    def self.invalid_dict_value?(value)
+      value.nil? || !value.instance_of?(Hash)
+    end
+
+    def self.serialize_value(value, context, collection_cases, union_types)
+      return serialize_array_of_dict_case(value, collection_cases) if
+        context.is_array && context.is_dict && context.is_array_of_dict
+
+      return serialize_dict_of_array_case(value, collection_cases) if
+        context.is_array && context.is_dict
+
+      return serialize_array_case(value, collection_cases) if context.is_array
+
+      return serialize_dict_case(value, collection_cases) if context.is_dict
+
+      get_serialized_value(union_types, value)
+    end
+
+    def self.serialize_array_of_dict_case(array_value, collection_cases)
+      serialized_value = []
+      array_value.each_with_index do |item, index|
+        serialized_value << serialize_dict_case(item, collection_cases[index])
+      end
+      serialized_value
+    end
+
+    def self.serialize_dict_of_array_case(dict_value, collection_cases)
+      serialized_value = {}
+      dict_value.each do |key, value|
+        serialized_value[key] = serialize_array_case(value, collection_cases[key])
+      end
+      serialized_value
+    end
+
+    def self.serialize_dict_case(dict_value, collection_cases)
+      serialized_value = {}
+      dict_value.each do |key, value|
+        valid_case = collection_cases[key].find(&:is_valid)
+        serialized_value[key] = valid_case.serialize(value)
+      end
+      serialized_value
+    end
+
+    def self.serialize_array_case(array_value, collection_cases)
+      serialized_value = []
+      array_value.each_with_index do |item, index|
+        valid_case = collection_cases[index].find(&:is_valid)
+        serialized_value << valid_case.serialize(item)
+      end
+      serialized_value
+    end
+
+    def self.get_serialized_value(union_types, value)
+      union_types.find(&:is_valid).serialize(value)
+    end
+
+    def self.deserialize_value(value, context, collection_cases, union_types, should_symbolize: false)
+      return deserialize_array_of_dict_case(value, collection_cases, should_symbolize: should_symbolize) if
+        context.is_array && context.is_dict && context.is_array_of_dict
+
+      return deserialize_dict_of_array_case(value, collection_cases, should_symbolize: should_symbolize) if
+        context.is_array && context.is_dict
+
+      return deserialize_array_case(value, collection_cases, should_symbolize: should_symbolize) if context.is_array
+      return deserialize_dict_case(value, collection_cases, should_symbolize: should_symbolize) if context.is_dict
+
+      get_deserialized_value(union_types, value, should_symbolize: should_symbolize)
+    end
+
+    def self.deserialize_array_of_dict_case(array_value, collection_cases, should_symbolize: false)
+      deserialized_value = []
+      array_value.each_with_index do |item, index|
+        deserialized_value << deserialize_dict_case(item, collection_cases[index], should_symbolize: should_symbolize)
+      end
+      deserialized_value
+    end
+
+    def self.deserialize_dict_of_array_case(dict_value, collection_cases, should_symbolize: false)
+      deserialized_value = {}
+      dict_value.each do |key, value|
+        deserialized_value[key] = deserialize_array_case(
+          value,
+          collection_cases[key],
+          should_symbolize: should_symbolize
+        )
+      end
+      deserialized_value
+    end
+
+    def self.deserialize_dict_case(dict_value, collection_cases, should_symbolize: false)
+      deserialized_value = {}
+      dict_value.each do |key, value|
+        valid_case = collection_cases[key].find(&:is_valid)
+        deserialized_value[key] = valid_case.deserialize(value, should_symbolize: should_symbolize)
+      end
+      deserialized_value
+    end
+
+    def self.deserialize_array_case(array_value, collection_cases, should_symbolize: false)
+      deserialized_value = []
+      array_value.each_with_index do |item, index|
+        valid_case = collection_cases[index].find(&:is_valid)
+        deserialized_value << valid_case.deserialize(item, should_symbolize: should_symbolize)
+      end
+      deserialized_value
+    end
+
+    def self.get_deserialized_value(union_types, value, should_symbolize: false)
+      union_types.find(&:is_valid).deserialize(value, should_symbolize: should_symbolize)
+    end
+
+    def self.process_errors(value, union_types, error_messages, is_nested, is_for_one_of)
+      error_messages << UnionTypeHelper.get_combined_error_messages(union_types).join(', ')
+
+      unless is_nested
+        UnionTypeHelper.raise_validation_exception(
+          value,
+          union_types,
+          error_messages.to_a.join(', '),
+          is_for_one_of
+        )
+      end
+
+      error_messages
+    end
+
+    def self.get_combined_error_messages(union_types)
+      combined_error_messages = []
+      union_types.each do |union_type|
+        if union_type.instance_of?(LeafType)
+          combined_error_messages << union_type.type_to_match.name
+        elsif union_type.error_messages
+          combined_error_messages << union_type.error_messages.to_a.join(', ')
+        end
+      end
+      combined_error_messages
+    end
+
+    def self.raise_validation_exception(value, union_types, error_message, is_for_one_of)
+      unless is_for_one_of
+        raise AnyOfValidationException,
+              "#{UnionTypeHelper::NONE_MATCHED_ERROR_MESSAGE}" \
+              "\nActual Value: #{ApiHelper.json_serialize(value)}\nExpected Type: Any Of #{error_message}."
+
+      end
+
+      matched_count = union_types.count(&:is_valid)
+      message = matched_count > 0 ?
+                  UnionTypeHelper::MORE_THAN_1_MATCHED_ERROR_MESSAGE : UnionTypeHelper::NONE_MATCHED_ERROR_MESSAGE
+
+      raise OneOfValidationException,
+            "#{message}\nActual Value: #{ApiHelper.json_serialize(value)}\nExpected Type: One Of #{error_message}."
+    end
+  end
+end

data/lib/apimatic_core.rb

@@ -14,6 +14,8 @@ require_relative 'apimatic-core/factories/http_response_factory'
 require_relative 'apimatic-core/configurations/global_configuration'
 
 require_relative 'apimatic-core/exceptions/invalid_auth_credential'
+require_relative 'apimatic-core/exceptions/any_of_validation_exception'
+require_relative 'apimatic-core/exceptions/one_of_validation_exception'
 
 require_relative 'apimatic-core/logger/endpoint_logger'
 
@@ -30,12 +32,18 @@ require_relative 'apimatic-core/types/sdk/validation_exception'
 require_relative 'apimatic-core/types/sdk/api_exception'
 require_relative 'apimatic-core/types/xml_attributes'
 
+require_relative 'apimatic-core/types/union_types/leaf_type'
+require_relative 'apimatic-core/types/union_types/any_of'
+require_relative 'apimatic-core/types/union_types/one_of'
+require_relative 'apimatic-core/types/union_types/union_type_context'
+
 require_relative 'apimatic-core/utilities/api_helper'
 require_relative 'apimatic-core/utilities/date_time_helper'
 require_relative 'apimatic-core/utilities/comparison_helper'
 require_relative 'apimatic-core/utilities/file_helper'
 require_relative 'apimatic-core/utilities/xml_helper'
 require_relative 'apimatic-core/utilities/auth_helper'
+require_relative 'apimatic-core/utilities/union_type_helper'
 
 require_relative 'apimatic-core/authentication/header_auth'
 require_relative 'apimatic-core/authentication/query_auth'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: apimatic_core
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - APIMatic Ltd.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-16 00:00:00.000000000 Z
+date: 2023-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: apimatic_core_interfaces
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -179,7 +179,9 @@ files:
 - lib/apimatic-core/authentication/multiple/single_auth.rb
 - lib/apimatic-core/authentication/query_auth.rb
 - lib/apimatic-core/configurations/global_configuration.rb
+- lib/apimatic-core/exceptions/any_of_validation_exception.rb
 - lib/apimatic-core/exceptions/invalid_auth_credential.rb
+- lib/apimatic-core/exceptions/one_of_validation_exception.rb
 - lib/apimatic-core/factories/http_response_factory.rb
 - lib/apimatic-core/http/configurations/http_client_configuration.rb
 - lib/apimatic-core/http/request/http_request.rb
@@ -194,12 +196,17 @@ files:
 - lib/apimatic-core/types/sdk/base_model.rb
 - lib/apimatic-core/types/sdk/file_wrapper.rb
 - lib/apimatic-core/types/sdk/validation_exception.rb
+- lib/apimatic-core/types/union_types/any_of.rb
+- lib/apimatic-core/types/union_types/leaf_type.rb
+- lib/apimatic-core/types/union_types/one_of.rb
+- lib/apimatic-core/types/union_types/union_type_context.rb
 - lib/apimatic-core/types/xml_attributes.rb
 - lib/apimatic-core/utilities/api_helper.rb
 - lib/apimatic-core/utilities/auth_helper.rb
 - lib/apimatic-core/utilities/comparison_helper.rb
 - lib/apimatic-core/utilities/date_time_helper.rb
 - lib/apimatic-core/utilities/file_helper.rb
+- lib/apimatic-core/utilities/union_type_helper.rb
 - lib/apimatic-core/utilities/xml_helper.rb
 - lib/apimatic_core.rb
 homepage: https://apimatic.io
@@ -221,7 +228,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: A library that contains apimatic-apimatic-core logic and utilities for consuming