spree_emerchantpay_genesis 0.1.3 → 0.1.4

data/app/helpers/spree_emerchantpay_genesis/mappers/threeds_attributes.rb

@@ -0,0 +1,227 @@
+module SpreeEmerchantpayGenesis
+  module Mappers
+    # Threeds V2 attributes Data Mapper
+    class ThreedsAttributes # rubocop:disable Metrics/ClassLength
+
+      attr_reader :context
+
+      include Spree::Core::Engine.routes.url_helpers
+
+      class << self
+
+        # Assign 3DSv2 attributes used for processing payments
+        def for_payment(genesis, order, source, options)
+          this = new genesis
+
+          this.map_processing_payment order, source, options
+        end
+
+        # Assign 3DSv2 attributes used for wpf payments
+        def for_wpf(genesis, order, options)
+          this = new genesis
+
+          this.map_wpf_payment order, options
+        end
+
+      end
+
+      # Initialize the mapper
+      def initialize(context)
+        @context = context
+      end
+
+      # Map processing 3DSv2 attributes
+      def map_processing_payment(order, source, options)
+        user_orders = fetch_user_orders order
+
+        method_attributes options
+        control_attributes options
+        purchase_attributes order
+        merchant_risk_attributes order, user_orders
+        card_holder_attributes order, user_orders
+        browser_attributes source
+
+        self
+      end
+
+      # Map WPF 3DSv2 attributes
+      def map_wpf_payment(order, options)
+        user_orders = fetch_user_orders order
+
+        control_attributes options, is_processing: false
+        purchase_attributes order
+        merchant_risk_attributes order, user_orders
+        card_holder_attributes order, user_orders
+
+        self
+      end
+
+      # Map Threeds Method attributes
+      def method_attributes(options)
+        @context.threeds_v2_method_callback_url =
+          "#{options[:hostname]}#{api_v2_storefront_emerchantpay_threeds_callback_handler_path}"
+
+        nil
+      end
+
+      def control_attributes(options, is_processing: true)
+        if is_processing
+          @context.threeds_v2_control_device_type = fetch_threeds_constant 'Control::DeviceTypes::BROWSER'
+        end
+
+        @context.threeds_v2_control_challenge_window_size =
+          fetch_threeds_constant('Control::ChallengeWindowSizes::FULLSCREEN')
+        @context.threeds_v2_control_challenge_indicator   = options[:challenge_indicator]
+
+        nil
+      end
+
+      # Map 3DSv2 Purchase Category
+      def purchase_attributes(order)
+        @context.threeds_v2_purchase_category = if order.digital
+                                                  fetch_threeds_constant('Purchase::Categories::SERVICE')
+                                                else
+                                                  fetch_threeds_constant('Purchase::Categories::GOODS')
+                                                end
+
+        nil
+      end
+
+      # Map 3DSv2 Merchant Risk
+      def merchant_risk_attributes(order, user_orders)
+        @context.threeds_v2_merchant_risk_shipping_indicator      = fetch_shipping_indicator order
+        @context.threeds_v2_merchant_risk_delivery_timeframe      = fetch_delivery_timeframe order
+        @context.threeds_v2_merchant_risk_reorder_items_indicator = fetch_reorder_items_indicator order, user_orders
+
+        nil
+      end
+
+      # 3DSv2 Card Holder Account attributes
+      def card_holder_attributes(order, user_orders) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        if order.user.empty?
+          @context.threeds_v2_card_holder_account_registration_indicator =
+            fetch_threeds_constant('CardHolderAccount::RegistrationIndicators::GUEST_CHECKOUT')
+
+          return nil
+        end
+
+        @context.threeds_v2_card_holder_account_creation_date = order.user.created_at_formatted
+
+        # Card Holder last changes with the 3DS requester
+        card_holder_updated_at = ThreedsHelper.fetch_last_change_date(
+          order.user.billing_address, order.user.shipping_address
+        )
+        @context.threeds_v2_card_holder_account_update_indicator = ThreedsHelper.fetch_class_indicator(
+          'UpdateIndicators', card_holder_updated_at
+        )
+        @context.threeds_v2_card_holder_account_last_change_date = card_holder_updated_at
+
+        # Card Holder Password changes
+        @context.threeds_v2_card_holder_account_password_change_indicator = ThreedsHelper.fetch_class_indicator(
+          'PasswordChangeIndicators', order.user.updated_at_formatted
+        )
+        @context.threeds_v2_card_holder_account_password_change_date = order.user.updated_at_formatted
+
+        # Card Holder Shipping Address first time used
+        shipping_address_first_used = ThreedsHelper.fetch_shipping_address_first_used order.user.shipping_address
+        @context.threeds_v2_card_holder_account_shipping_address_usage_indicator = ThreedsHelper.fetch_class_indicator(
+          'ShippingAddressUsageIndicators', shipping_address_first_used
+        )
+        @context.threeds_v2_card_holder_account_shipping_address_date_first_used = shipping_address_first_used
+
+        # Card Holder Payments count
+        activity_last24_hours = ThreedsHelper.filter_transaction_activity_24_hours user_orders
+        if activity_last24_hours.positive?
+          @context.threeds_v2_card_holder_account_transactions_activity_last24_hours = activity_last24_hours
+        end
+
+        previous_year_count = ThreedsHelper.filter_transaction_activity_previous_year user_orders
+        if previous_year_count.positive?
+          @context.threeds_v2_card_holder_account_transactions_activity_previous_year = previous_year_count
+        end
+
+        purchases_last6_months = ThreedsHelper.filter_purchases_count_last6_months user_orders
+        if purchases_last6_months.positive?
+          @context.threeds_v2_card_holder_account_purchases_count_last6_months = purchases_last6_months
+        end
+
+        # Card Holder registration with the 3D requester
+        first_completed_payment = ThreedsHelper.filter_first_completed_payment user_orders
+        unless first_completed_payment.empty?
+          string_date = DateTime.parse(first_completed_payment['payment_created_at'].to_s)
+                                .strftime(ThreedsHelper::DATE_ISO_FORMAT)
+
+          @context.threeds_v2_card_holder_account_registration_indicator = ThreedsHelper.fetch_class_indicator(
+            'RegistrationIndicators', string_date
+          )
+          @context.threeds_v2_card_holder_account_registration_date = string_date
+        end
+
+        nil
+      end
+
+      # 3DSv2 Browser attributes
+      def browser_attributes(source) # rubocop:disable Metrics/AbcSize
+        @context.threeds_v2_browser_accept_header    = source.public_metadata[:accept_header]
+        @context.threeds_v2_browser_java_enabled     = ActiveModel::Type::Boolean.new.cast(
+          source.public_metadata[:java_enabled]
+        )
+        @context.threeds_v2_browser_language         = source.public_metadata[:language]
+        @context.threeds_v2_browser_color_depth      = source.public_metadata[:color_depth]
+        @context.threeds_v2_browser_screen_height    = source.public_metadata[:screen_height]
+        @context.threeds_v2_browser_screen_width     = source.public_metadata[:screen_width]
+        @context.threeds_v2_browser_time_zone_offset = source.public_metadata[:time_zone_offset]
+        @context.threeds_v2_browser_user_agent       = source.public_metadata[:user_agent]
+      end
+
+      private
+
+      # Helper method for 3DSv2 constants
+      def fetch_threeds_constant(constant)
+        "#{ThreedsHelper::CONSTANT_PATH}#{constant}".constantize
+      end
+
+      # Fetch User Orders
+      def fetch_user_orders(order)
+        return SpreeOrderRepository.orders_by_user order.user_id if order.user_id
+
+        []
+      end
+
+      # Fetch 3DSv2 Merchant Risk Shipping Indicator
+      def fetch_shipping_indicator(order)
+        return fetch_threeds_constant('MerchantRisk::ShippingIndicators::DIGITAL_GOODS') if order.digital
+
+        if order.shipping_address&.to_s == order.billing_address&.to_s
+          return fetch_threeds_constant 'MerchantRisk::ShippingIndicators::SAME_AS_BILLING'
+        end
+
+        return fetch_threeds_constant 'MerchantRisk::ShippingIndicators::STORED_ADDRESS' if order.user_id
+
+        fetch_threeds_constant 'MerchantRisk::ShippingIndicators::OTHER'
+      end
+
+      # Fetch 3DSv2 Merchant Risk Delivery Timeframe
+      def fetch_delivery_timeframe(order)
+        return fetch_threeds_constant 'MerchantRisk::DeliveryTimeframes::ELECTRONICS' if order.digital
+
+        fetch_threeds_constant 'MerchantRisk::DeliveryTimeframes::ANOTHER_DAY'
+      end
+
+      # Fetch 3DSv2 Merchant Risk Reorder Items Indicator
+      def fetch_reorder_items_indicator(order, user_orders)
+        return fetch_threeds_constant 'MerchantRisk::ReorderItemIndicators::FIRST_TIME' unless order.user_id
+
+        variants = []
+        order.line_items.each { |line_item| variants.push line_item[:variant_id] }
+
+        reordered = SpreeOrderRepository.reordered_variant? order.id, variants, user_orders
+
+        return fetch_threeds_constant 'MerchantRisk::ReorderItemIndicators::REORDERED' if reordered
+
+        fetch_threeds_constant 'MerchantRisk::ReorderItemIndicators::FIRST_TIME'
+      end
+
+    end
+  end
+end

data/app/helpers/spree_emerchantpay_genesis/payment_method_helper.rb

@@ -0,0 +1,34 @@
+module SpreeEmerchantpayGenesis
+  # Helper methods used in the transaction processing
+  class PaymentMethodHelper
+
+    DIRECT_PAYMENT   = 'emerchantpay_direct'.freeze
+    CHECKOUT_PAYMENT = 'emerchantpay_checkout'.freeze
+
+    class << self
+
+      # Fetch the Payment type from the given Payment Method
+      def fetch_method_type(payment_method)
+        case payment_method
+        when Spree::Gateway::EmerchantpayDirect.name
+          DIRECT_PAYMENT
+        when Spree::Gateway::EmerchantpayCheckout.name
+          CHECKOUT_PAYMENT
+        else
+          ''
+        end
+      end
+
+      # Build Checkout source attribute if source_attributes are not present?
+      def default_checkout_source_attributes(order)
+        default_attr = { name: CHECKOUT_PAYMENT }
+
+        default_attr.merge!({ consumer_email: order.email }) if order&.email
+
+        default_attr
+      end
+
+    end
+
+  end
+end

data/app/helpers/spree_emerchantpay_genesis/threeds_helper.rb

@@ -8,6 +8,7 @@ module SpreeEmerchantpayGenesis
     CURRENT_TRANSACTION_INDICATOR  = 'current_transaction'.freeze
     DATE_ISO_FORMAT                = GenesisRuby::Api::Constants::DateTimeFormats::YYYY_MM_DD_ISO_8601
     COMPLETED_SPREE_PAYMENT_STATE  = 'completed'.freeze
+    CONSTANT_PATH                  = 'GenesisRuby::Api::Constants::Transactions::Parameters::Threeds::Version2::'.freeze
 
     class << self
 
@@ -70,7 +71,7 @@ module SpreeEmerchantpayGenesis
 
       # Fetch the given 3DSv2 parameter indicator
       def fetch_class_indicator(indicator_class, updated_at) # rubocop:disable Metrics/MethodLength
-        constant_path = 'GenesisRuby::Api::Constants::Transactions::Parameters::Threeds::Version2::CardHolderAccount::'
+        constant_path = "#{CONSTANT_PATH}CardHolderAccount::"
 
         case fetch_indicator updated_at
         when LESS_THAN_30_DAYS_INDICATOR

data/app/helpers/spree_emerchantpay_genesis/transaction_helper.rb

@@ -6,6 +6,7 @@ module SpreeEmerchantpayGenesis
     CAPTURE_ACTION        = 'capture'.freeze
     REFUND_ACTION         = 'refund'.freeze
     VOID_ACTION           = 'void'.freeze
+    WPF_TRANSACTION_TYPE  = 'checkout'.freeze
 
     class << self
 
@@ -29,7 +30,7 @@ module SpreeEmerchantpayGenesis
 
       # Check given response for asynchronous execution
       def async_result?(response)
-        response.pending? || response.pending_async? || response.in_progress? || response.pending_hold?
+        response.pending? || response.pending_async? || response.in_progress? || response.pending_hold? || response.new?
       end
 
       # Check given response for Method Continue parameters
@@ -39,7 +40,7 @@ module SpreeEmerchantpayGenesis
 
       # Check given response for failure
       def failure_result?(response)
-        response.error? || response.declined?
+        response.error? || response.declined? || response.timeout?
       end
 
       # Generate Spree Response from Gateway action
@@ -71,9 +72,7 @@ module SpreeEmerchantpayGenesis
       end
 
       # Check if the given Genesis Response can be stored
-      def can_save_genesis_response?(response)
-        response_object = response.response_object
-
+      def can_save_genesis_response?(response_object)
         !(
           response_object[:transaction_id].nil? ||
             response_object[:transaction_type].nil? ||
@@ -109,6 +108,11 @@ module SpreeEmerchantpayGenesis
         GenesisRuby::Api::Requests::Financial::Cards::Threeds::V2::MethodContinue.new configuration
       end
 
+      # Initialize WPF API Request
+      def init_wpf_req(configuration)
+        GenesisRuby::Api::Requests::Wpf::Create.new configuration
+      end
+
       # Fetch Redirect Url from Genesis Response
       def fetch_redirect_url(options, response)
         url = ''

data/app/models/spree/emerchantpay_checkout_source.rb

@@ -0,0 +1,37 @@
+module Spree
+  # Emerchantpay Checkout Source
+  class EmerchantpayCheckoutSource < Spree::Base
+
+    acts_as_paranoid
+
+    self.table_name = 'emerchantpay_checkout_sources'
+
+    belongs_to :payment_method
+    belongs_to :user, class_name: Spree.user_class.to_s, foreign_key: 'user_id',
+               optional: true
+    has_many :payments, as: :source
+
+    include Spree::Metadata
+
+    def actions
+      %w(capture void credit)
+    end
+
+    # Indicates whether its possible to capture the payment
+    def can_capture?(payment)
+      payment.pending? || payment.checkout?
+    end
+
+    # Indicates whether its possible to void the payment.
+    def can_void?(payment)
+      !payment.failed? && !payment.void?
+    end
+
+    # Indicates whether its possible to credit the payment.  Note that most gateways require that the
+    # payment be settled first which generally happens within 12-24 hours of the transaction.
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed.positive?
+    end
+
+  end
+end

data/app/models/spree/gateway/emerchantpay_checkout.rb

@@ -0,0 +1,52 @@
+module Spree
+  # Emerchantpay Checkout Payment Method
+  class Gateway::EmerchantpayCheckout < SpreeEmerchantpayGenesis::Base::Gateway # rubocop:disable Style/ClassAndModuleChildren
+
+    preference :transaction_types, :multi_select,  default: lambda {
+      { values: GenesisRuby::Utils::Transactions::WpfTypes.all }
+    }
+    preference :return_cancel_url, :string, default: 'http://localhost:4000/checkout/payment'
+    preference :return_pending_url, :string, default: 'http://localhost:4000/orders/|:ORDER:|'
+
+    delegate :load_data, :load_source, :load_payment, to: :provider
+
+    def method_type
+      SpreeEmerchantpayGenesis::PaymentMethodHelper::CHECKOUT_PAYMENT
+    end
+
+    def purchase(_money_in_cents, source, gateway_options)
+      order, payment = order_data_from_options gateway_options
+      user           = order.user
+
+      prepare_provider(
+        SpreeEmerchantpayGenesis::Mappers::Order.prepare_data(order, user, gateway_options),
+        source,
+        payment
+      )
+
+      provider.purchase
+    end
+
+    def source_required?
+      true
+    end
+
+    def payment_source_class
+      EmerchantpayCheckoutSource
+    end
+
+    def auto_capture?
+      false
+    end
+
+    private
+
+    # Prepare provider
+    def prepare_provider(data, source, payment)
+      load_data SpreeEmerchantpayGenesis::Mappers::Order.for data
+      load_source source
+      load_payment payment
+    end
+
+  end
+end

data/app/models/spree/gateway/emerchantpay_direct.rb

@@ -3,21 +3,14 @@ module Spree
   class Gateway::EmerchantpayDirect < SpreeEmerchantpayGenesis::Base::Gateway # rubocop:disable Style/ClassAndModuleChildren
 
     preference :token, :string
+    preference :transaction_types, :select,  default: lambda {
+      { values: [:authorize, :authorize3d, :sale, :sale3d] }
+    }
 
     delegate :load_data, :load_source, :load_payment, to: :provider
 
     def method_type
-      'emerchantpay_direct'
-    end
-
-    def provider_class
-      SpreeEmerchantpayGenesis::GenesisProvider
-    end
-
-    def provider
-      @provider = provider_class.new options if @provider.nil?
-
-      @provider
+      SpreeEmerchantpayGenesis::PaymentMethodHelper::DIRECT_PAYMENT
     end
 
     def purchase(_money_in_cents, source, gateway_options)
@@ -33,14 +26,6 @@ module Spree
       provider.purchase
     end
 
-    def authorize(money_in_cents, source, gateway_options)
-      purchase money_in_cents, source, gateway_options
-    end
-
-    def supports?(_source)
-      true
-    end
-
     def source_required?
       true
     end

data/app/models/spree/payment_decorator.rb

@@ -7,6 +7,37 @@ module Spree
       SpreeEmerchantpayGenesis::EmerchantpayPaymentsRepository.find_all_by_order_and_payment order.number, number
     end
 
+    # Monkey patch for Emerchantpay Checkout Source
+    # see https://github.com/spree/spree/issues/981
+    def build_source
+      return unless new_record?
+
+      if default_emerchantpay_checkout_source?
+        self.source_attributes = SpreeEmerchantpayGenesis::PaymentMethodHelper.default_checkout_source_attributes order
+      end
+
+      build_default_source if can_build_source?
+    end
+
+    private
+
+    # Check if emerchantpay checkout source should be build with the default source_attributes
+    def default_emerchantpay_checkout_source?
+      payment_method.is_a?(Spree::Gateway::EmerchantpayCheckout) && !source_attributes.present?
+    end
+
+    # Check if can build source
+    def can_build_source?
+      source_attributes.present? && source.blank? && payment_method.try(:payment_source_class)
+    end
+
+    # Default Spree build source logic
+    def build_default_source
+      self.source = payment_method.payment_source_class.new(source_attributes)
+      source.payment_method_id = payment_method.id
+      source.user_id = order.user_id if order
+    end
+
   end
 end
 

data/app/models/spree_emerchantpay_genesis/base/gateway.rb

@@ -5,7 +5,6 @@ module SpreeEmerchantpayGenesis
 
       preference :username, :string
       preference :password, :string
-      preference :transaction_types, :select,  default: -> { { values: [:authorize, :authorize3d, :sale, :sale3d] } }
       preference :return_success_url, :string, default: 'http://localhost:4000/orders/|:ORDER:|'
       preference :return_failure_url, :string, default: 'http://localhost:4000/checkout/payment?order_number=|:ORDER:|'
       preference :threeds_allowed, :boolean_select, default: true
@@ -15,6 +14,20 @@ module SpreeEmerchantpayGenesis
       preference :hostname, :string, default: 'http://127.0.0.1:4000'
       preference :test_mode, :boolean_select, default: true
 
+      def provider_class
+        SpreeEmerchantpayGenesis::GenesisProvider
+      end
+
+      def provider
+        @provider = provider_class.new method_type, options if @provider.nil?
+
+        @provider
+      end
+
+      def authorize(money_in_cents, source, gateway_options)
+        purchase money_in_cents, source, gateway_options
+      end
+
       # Capture authorized payment
       def capture(amount, transaction_id, gateway_options)
         order, payment = order_data_from_options gateway_options
@@ -53,6 +66,10 @@ module SpreeEmerchantpayGenesis
         false
       end
 
+      def supports?(_source)
+        true
+      end
+
       def order_data_from_options(options)
         order_number, payment_number = options[:order_id].split('-')
         order = Spree::Order.find_by(number: order_number)

data/app/models/spree_emerchantpay_genesis/genesis_provider.rb

@@ -5,9 +5,10 @@ module SpreeEmerchantpayGenesis
     attr_reader :provider_data
 
     # Constructor
-    def initialize(options)
-      @options           = options
-      @configuration     = Mappers::Genesis.for_config(@options).context
+    def initialize(method_type, options)
+      @options       = options
+      @configuration = Mappers::Genesis.for_config(@options).context
+      @method_type   = method_type
     end
 
     # Load Order data
@@ -32,16 +33,11 @@ module SpreeEmerchantpayGenesis
     # Create a payment
     def purchase
       safe_execute do
-        genesis_request = TransactionHelper.init_genesis_req @configuration, @options[:transaction_types]
-
-        genesis = GenesisRuby::Genesis.new(
-          @configuration,
-          Mappers::Genesis.for_payment(genesis_request, @order, @source, @options).context
-        )
+        genesis = init_gateway_req
 
         response = genesis.execute.response
 
-        handle_response genesis_request, response
+        handle_response genesis.request, response
 
         response
       end
@@ -140,12 +136,14 @@ module SpreeEmerchantpayGenesis
 
     # Handle Genesis Response
     def handle_response(request, response, is_payment: true)
-      if TransactionHelper.can_save_genesis_response? response
-        EmerchantpayPaymentsRepository.save_from_response_data request, response, @order, @payment
+      response_object = fetch_response_object response
+
+      if TransactionHelper.can_save_genesis_response? response_object
+        EmerchantpayPaymentsRepository.save_from_response_data request, response_object, @order, @payment
       end
 
-      SpreePaymentsRepository.update_payment @payment, response if is_payment
-      SpreePaymentsRepository.add_payment_metadata @payment, @options, response
+      SpreePaymentsRepository.update_payment @payment, response_object if is_payment
+      SpreePaymentsRepository.add_payment_metadata @payment, @options, response, response_object
 
       # Missing shipping amount fix
       @payment.amount = response.response_object[:amount] if response.response_object&.key?(:amount) && is_payment
@@ -158,11 +156,13 @@ module SpreeEmerchantpayGenesis
 
     # Handle Genesis Notification Response
     def handle_reconciliation_response(emerchantpay_payment, reconciliation)
-      EmerchantpayPaymentsRepository.update_from_response_data(emerchantpay_payment, reconciliation, @payment)
+      response_object = fetch_reconciliation_object reconciliation, emerchantpay_payment.unique_id
+
+      EmerchantpayPaymentsRepository.update_from_response_data emerchantpay_payment, response_object, @payment
 
-      SpreePaymentsRepository.update_payment @payment, reconciliation
-      SpreePaymentsRepository.add_payment_metadata @payment, @options, reconciliation
-      SpreePaymentsRepository.update_payment_status @payment, reconciliation
+      SpreePaymentsRepository.update_payment @payment, response_object
+      SpreePaymentsRepository.add_payment_metadata @payment, @options, reconciliation, response_object
+      SpreePaymentsRepository.update_payment_status @payment, reconciliation, response_object[:transaction_type]
 
       @payment.save
 
@@ -199,5 +199,61 @@ module SpreeEmerchantpayGenesis
       @options
     end
 
+    # Initialize Gateway API Request
+    def init_gateway_req
+      case @method_type
+      when PaymentMethodHelper::CHECKOUT_PAYMENT
+        init_wpf_api
+      when PaymentMethodHelper::DIRECT_PAYMENT
+        init_processing_api
+      else
+        raise GenesisRuby::Error, 'Invalid Payment Method Type given!'
+      end
+    end
+
+    # Init Processing API Request
+    def init_processing_api
+      genesis_request = TransactionHelper.init_genesis_req @configuration, @options[:transaction_types]
+
+      GenesisRuby::Genesis.new(
+        @configuration,
+        Mappers::Genesis.for_payment(genesis_request, @order, @source, @options).context
+      )
+    end
+
+    # Init WPF API Request
+    def init_wpf_api
+      genesis_request = TransactionHelper.init_wpf_req @configuration
+
+      GenesisRuby::Genesis.new(
+        @configuration,
+        Mappers::Genesis.for_wpf(genesis_request, @order, @source, @options).context
+      )
+    end
+
+    # Prepare the response object
+    def fetch_response_object(genesis_response)
+      response_object = genesis_response.response_object
+      test_mode       = ActiveModel::Type::Boolean.new.cast(@options[:test_mode]) ? 'test' : 'live'
+
+      if @method_type == PaymentMethodHelper::CHECKOUT_PAYMENT && genesis_response.new?
+        response_object.merge!(
+          { transaction_type: TransactionHelper::WPF_TRANSACTION_TYPE, mode: test_mode, terminal_token: '' }
+        )
+      end
+
+      response_object
+    end
+
+    # Fetch the payment_transaction object from the given reconciliation response
+    def fetch_reconciliation_object(reconciliation, unique_id)
+      response_object = reconciliation.response_object
+
+      return response_object unless response_object.key? :payment_transaction
+      return response_object[:payment_transaction] if response_object[:payment_transaction].is_a? Hash
+
+      response_object[:payment_transaction].select { |payment| payment[:unique_id] == unique_id }.first
+    end
+
   end
 end