ledger_sync 1.6.0 → 1.7.0

data/lib/ledger_sync/ledgers/quickbooks_online/serializer.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-# Gem.find_files('ledger_sync/ledgers/quickbooks_online/serializer_type/**/*.rb').each { |path| require path }
-
-module LedgerSync
-  module Ledgers
-    module QuickBooksOnline
-      class Serializer < LedgerSync::Serializer
-        def serialize(args = {})
-          deep_merge_unmapped_values = args.fetch(:deep_merge_unmapped_values, {})
-          only_changes               = args.fetch(:only_changes, false)
-          resource                   = args.fetch(:resource)
-
-          ret = super(
-            only_changes: only_changes,
-            resource: resource
-          )
-          return ret unless deep_merge_unmapped_values.any?
-
-          deep_merge_if_not_mapped(
-            current_hash: ret,
-            hash_to_search: deep_merge_unmapped_values
-          )
-        end
-
-        def self.amount(hash_attribute, args = {})
-          attribute(
-            hash_attribute,
-            {
-              type: Serialization::Type::IntegerToAmountFloatType.new
-            }.merge(args)
-          )
-        end
-
-        def self.date(hash_attribute, args = {})
-          attribute(
-            hash_attribute,
-            {
-              type: LedgerSync::Serialization::Type::FormatDateType.new(format: '%Y-%m-%d')
-            }.merge(args)
-          )
-        end
-
-        def self.id
-          attribute('Id', resource_attribute: :ledger_id)
-        end
-
-        private
-
-        def deep_merge_if_not_mapped(current_hash:, hash_to_search:)
-          hash_to_search.each do |key, value|
-            current_hash[key] = if current_hash.key?(key)
-                                  if value.is_a?(Hash) && current_hash[key].present?
-                                    deep_merge_if_not_mapped(
-                                      current_hash: current_hash[key],
-                                      hash_to_search: value
-                                    )
-                                  else
-                                    current_hash[key]
-                                  end
-                                else
-                                  value
-                                end
-          end
-
-          current_hash
-        end
-      end
-    end
-  end
-end

data/lib/ledger_sync/ledgers/quickbooks_online/serialziation/type/mapping_type.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module LedgerSync
-  module QuickBooksOnline
-    module Serialization
-      module Type
-        class MappingType < LedgerSync::Type::Value
-          attr_reader :mapping
-
-          def initialize(args = {})
-            @mapping = args.fetch(:mapping)
-
-            super()
-          end
-
-          def cast_value(args = {})
-            value = args.fetch(:value)
-
-            return if value.nil?
-
-            mapping.fetch(:value)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ledger_sync/ledgers/quickbooks_online/transfer/deserializer.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../reference/deserializer'
-
-module LedgerSync
-  module Ledgers
-    module QuickBooksOnline
-      class Transfer
-        class Deserializer < QuickBooksOnline::Deserializer
-          id
-
-          amount :Amount
-          attribute :PrivateNote
-          date :TxnDate
-
-          references_one :FromAccount,
-                         hash_attribute: 'FromAccountRef',
-                         deserializer: Reference::Deserializer
-
-          references_one :ToAccount,
-                         hash_attribute: 'ToAccountRef',
-                         deserializer: Reference::Deserializer
-
-          references_one :Currency,
-                         hash_attribute: 'CurrencyRef',
-                         deserializer: Reference::Deserializer
-        end
-      end
-    end
-  end
-end

data/lib/ledger_sync/ledgers/quickbooks_online/transfer/operations/create.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module LedgerSync
-  module Ledgers
-    module QuickBooksOnline
-      class Transfer
-        module Operations
-          class Create < Operation::Create
-            class Contract < LedgerSync::Ledgers::Contract
-              params do
-                required(:external_id).maybe(:string)
-                required(:ledger_id).value(:nil)
-                required(:FromAccount).hash(Types::Reference)
-                required(:ToAccount).hash(Types::Reference)
-                required(:Amount).filled(:integer)
-                required(:Currency).filled(:hash, Types::Reference)
-                required(:PrivateNote).filled(:string)
-                required(:TxnDate).filled(:date?)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ledger_sync/ledgers/quickbooks_online/transfer/operations/find.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module LedgerSync
-  module Ledgers
-    module QuickBooksOnline
-      class Transfer
-        module Operations
-          class Find < Operation::Find
-            class Contract < LedgerSync::Ledgers::Contract
-              schema do
-                required(:external_id).maybe(:string)
-                required(:ledger_id).filled(:string)
-                optional(:FromAccount).hash(Types::Reference)
-                optional(:ToAccount).hash(Types::Reference)
-                optional(:Amount).maybe(:integer)
-                optional(:Currency).maybe(:hash, Types::Reference)
-                optional(:PrivateNote).maybe(:string)
-                optional(:TxnDate).maybe(:date?)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ledger_sync/ledgers/quickbooks_online/transfer/operations/update.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module LedgerSync
-  module Ledgers
-    module QuickBooksOnline
-      class Transfer
-        module Operations
-          class Update < Operation::FullUpdate
-            class Contract < LedgerSync::Ledgers::Contract
-              schema do
-                required(:external_id).maybe(:string)
-                required(:ledger_id).filled(:string)
-                required(:FromAccount).hash(Types::Reference)
-                required(:ToAccount).hash(Types::Reference)
-                required(:Amount).filled(:integer)
-                required(:Currency).filled(:hash, Types::Reference)
-                required(:PrivateNote).filled(:string)
-                required(:TxnDate).filled(:date?)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ledger_sync/ledgers/quickbooks_online/transfer/serializer.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../reference/serializer'
-
-module LedgerSync
-  module Ledgers
-    module QuickBooksOnline
-      class Transfer
-        class Serializer < QuickBooksOnline::Serializer
-          id
-
-          amount :Amount
-          attribute :PrivateNote
-          date :TxnDate
-
-          references_one 'FromAccountRef',
-                         resource_attribute: :FromAccount,
-                         serializer: Reference::Serializer
-
-          references_one 'ToAccountRef',
-                         resource_attribute: :ToAccount,
-                         serializer: Reference::Serializer
-
-          references_one 'CurrencyRef',
-                         resource_attribute: :Currency,
-                         serializer: Reference::Serializer
-        end
-      end
-    end
-  end
-end

data/lib/ledger_sync/ledgers/quickbooks_online/util/error_matcher.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module LedgerSync
-  module Ledgers
-    module QuickBooksOnline
-      class Util
-        class ErrorMatcher
-          attr_reader :error,
-                      :message
-
-          def initialize(error:)
-            @error = error
-            @message = error.message.to_s
-          end
-
-          def body
-            @body ||= error.response.body
-          rescue NoMethodError
-            nil
-          end
-
-          def error_class
-            raise NotImplementedError
-          end
-
-          def error_message
-            return error.message unless body
-
-            fault&.fetch('message', nil) ||
-              fault&.fetch('Message', nil) ||
-              parsed_body['error']
-          end
-
-          def detail
-            return if body.blank?
-
-            fault&.fetch('detail') ||
-              fault&.fetch('Detail')
-          end
-
-          def code
-            return if body.blank?
-
-            fault&.fetch('code') ||
-              fault&.fetch('code').to_i
-          end
-
-          def match?
-            raise NotImplementedError
-          end
-
-          def parsed_body
-            @parsed_body ||= JSON.parse(body)
-          end
-
-          def output_message
-            raise NotImplementedError
-          end
-
-          private
-
-          def fault
-            parsed_body.dig('fault', 'error')&.first ||
-              parsed_body.dig('Fault', 'Error')&.first
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ledger_sync/ledgers/quickbooks_online/util/error_parser.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'error_matcher'
-
-module LedgerSync
-  module Ledgers
-    module QuickBooksOnline
-      class Util
-        class ErrorParser
-          attr_reader :error
-
-          def initialize(error:)
-            @error = error
-          end
-
-          def error_class
-            raise NotImplementedError
-          end
-
-          def parse
-            raise NotImplementedError
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ledger_sync/ledgers/quickbooks_online/util/ledger_error_parser.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'error_parser'
-
-module LedgerSync
-  module Ledgers
-    module QuickBooksOnline
-      class Util
-        class LedgerErrorParser < ErrorParser
-          class ThrottleMatcher < ErrorMatcher
-            def error_class
-              Error::LedgerError::ThrottleError
-            end
-
-            def output_message
-              "Request throttle with: #{error_message}"
-            end
-
-            def match?
-              message.include?('source=throttling policy') ||
-                message.include?('errorcode=003001')
-            end
-          end
-
-          class AuthenticationMatcher < ErrorMatcher
-            def error_class
-              Error::LedgerError::AuthenticationError
-            end
-
-            def output_message
-              "Authentication Failed with: #{error_message}"
-            end
-
-            def match?
-              code == 3200 ||
-                message.include?('authenticationfailed') ||
-                message.include?('errorcode=003200')
-            end
-          end
-
-          class AuthorizationMatcher < ErrorMatcher
-            def error_class
-              Error::LedgerError::AuthorizationError
-            end
-
-            def output_message
-              "Authorization Failed with: #{error_message}"
-            end
-
-            def match?
-              code == 3100 ||
-                message.include?('authorizationfailed') ||
-                message.include?('errorcode=003100')
-            end
-          end
-
-          class ClientMatcher < ErrorMatcher
-            def error_class
-              Error::LedgerError::ConfigurationError
-            end
-
-            def output_message
-              "Missing Configuration: #{error_message}"
-            end
-
-            def match?
-              message.include?('invalid_client') ||
-                message.include?('invalid_grant')
-            end
-          end
-
-          PARSERS = [
-            AuthenticationMatcher,
-            AuthorizationMatcher,
-            ClientMatcher,
-            ThrottleMatcher
-          ].freeze
-
-          attr_reader :client
-
-          def initialize(client:, error:)
-            @client = client
-            super(error: error)
-          end
-
-          def parse
-            PARSERS.map do |parser|
-              matcher = parser.new(error: error)
-              next unless matcher.match?
-
-              return matcher.error_class.new(
-                client: client,
-                message: matcher.output_message,
-                response: error
-              )
-            end
-            nil
-          end
-        end
-      end
-    end
-  end
-end