flowcommerce_spree 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51a668ee3cc70d0bc9bd8c7662a972f086e06dcdcf4c68df2177e94818dfb820
-  data.tar.gz: aa9ff17e57cd19452736af11d51bd1905c4dd7e66bb461b5dff017fc5dea0b0d
+  metadata.gz: 3810faadd82b0d21c0bacaeaa6be61bfe314ddffe4f32a6805c05554c592a745
+  data.tar.gz: 6d042ed69b193082492ac992ea3d4a9bd962e493ae49026a43c297492013b4ea
 SHA512:
-  metadata.gz: 024a29a6fc47f932e432f2477f9a1f3b520af7cc10b7a85eb35613328276d5390a682187151217c0527b20435431f78e8cc55255d95298620bfb5077c7ed5011
-  data.tar.gz: b6d9485612e360ed50caabfab537baf9583feec384607b4a890c1ab1fd9fc48cd9ea3954562aac828f4a858682ad1515ae7f2b9bf05a8a501ff8abf96c28f972
+  metadata.gz: 6bd6d8e87e8f5d8c5d30d9f4366bc0e6d06dc95504d6f8cd3fc8916c752478123e80671ac5da4063a02c6051eb56d95f14ef97d782249a7fa9cb1df4e983829f
+  data.tar.gz: 260d3b14add605bc114bd561a39f7376a88850d4aea95a98339db5461a9845463a87da1cd845cf68a6b8732a88d7f445a8961fb4f5a0847c282130efeb247083

data/app/controllers/concerns/current_zone_loader_decorator.rb

@@ -20,12 +20,11 @@ CurrentZoneLoader.module_eval do
     session['region'] = { name: current_zone_name, available_currencies: @current_zone.available_currencies,
                           request_iso_code: request_iso_code }
 
-    RequestStore.store[:session] = session
     Rails.logger.debug("Using product zone: #{current_zone_name}")
     @current_zone
   end
 
-  def flow_zone # rubocop:disable Metrics/AbcSize
+  def flow_zone
     return unless Spree::Zones::Product.active
                                        .where("meta -> 'flow_data' ->> 'country' = ?",
                                               ISO3166::Country[request_iso_code]&.alpha3).exists?
@@ -36,13 +35,13 @@ CurrentZoneLoader.module_eval do
                    Spree::Config[:debug_request_ip_address] || request.ip
                    # Germany ip: 85.214.132.117, Sweden ip: 62.20.0.196, Moldova ip: 89.41.76.29
                  end
+
+    # This will issue a session creation request to flow.io. The response will contain the Flow Experience key and
+    # the session_id
     flow_io_session = FlowcommerceSpree::Session.create(ip: request_ip, visitor: visitor_id_for_flow_io)
-    # :create method will issue a request to flow.io. The experience, contained in the
-    # response, will be available in the session object - flow_io_session.experience
 
     if (zone = Spree::Zones::Product.active.find_by(name: flow_io_session.experience&.key&.titleize))
-      session['_f60_session'] = flow_io_session.id
-      session['_f60_expires_at'] = flow_io_session.expires_at.to_s
+      session['flow_session_id'] = flow_io_session.id
     end
 
     zone

data/app/controllers/flowcommerce_spree/inventory_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class InventoryController < ActionController::Base
+    def online_stock_availability
+      items = params['items'] || []
+      response = items.inject([]) { |result, item| result << check_stock(item[:id], item[:qty].to_i) }
+      render json: { items: response }, status: :ok
+    end
+
+    private
+
+    def check_stock(flow_number, quantity)
+      variant = Spree::Variant.find_by(sku: flow_number)
+      return { id: flow_number, has_inventory: false } unless variant
+
+      { id: flow_number, has_inventory: variant.available_online?(quantity) }
+    rescue StandardError
+      Rails.logger.error "[!] FlowcommerceSpree::InventoryController#stock unexpected Error: #{$ERROR_INFO}"
+      { id: flow_number, has_inventory: false }
+    end
+  end
+end

data/app/controllers/flowcommerce_spree/orders_controller.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class OrdersController < ApplicationController
+    wrap_parameters false
+
+    skip_before_action :setup_tracking, only: :order_completed
+
+    # proxy enpoint between flow and thankyou page.
+    # /flow/order_completed endpoint
+    def order_completed
+      flow_updater = FlowcommerceSpree::OrderUpdater.new(order: current_order)
+      flow_updater.complete_checkout
+
+      redirect_to "/thankyou?order=#{params[:order]}&t=#{params[:t]}"
+    end
+  end
+end

data/app/controllers/users/sessions_controller_decorator.rb

@@ -2,10 +2,27 @@
 
 module Users
   SessionsController.class_eval do
+    # This endpoint is for returning to the FrontEnd the dynamic url to an external checkout, a flow.io url.
+    def checkout_url
+      flow_session_id = request.headers['flow-session-id']
+      return render json: { error: :session_id_missing }, status: 422 if flow_session_id.blank?
+
+      checkout_token =
+        FlowcommerceSpree::OrderSync.new(order: current_order, flow_session_id: flow_session_id).synchronize!
+      return render json: { error: :checkout_token_missing }, status: 422 if checkout_token.blank?
+
+      render json: { checkout_url: "https://checkout.flow.io/tokens/#{checkout_token}" }, status: 200
+    end
+
     private
 
-    def external_checkout?
-      current_zone.flow_io_active_experience? ? 'true' : 'false'
+    def add_optional_attrs(session_current)
+      session_current['user'] = current_user_attrs if current_user&.spree_api_key?
+      session_current['region'] = zone_attrs
+
+      external_checkout = current_zone.flow_io_active_experience?
+      session_current['external_checkout'] = external_checkout
+      session_current['flow_session_id'] = session['flow_session_id'] if external_checkout
     end
   end
 end

data/app/helpers/spree/core/controller_helpers/flow_io_order_helper_decorator.rb

@@ -17,22 +17,6 @@ module Spree
               @current_order.flow_io_experience_from_zone
               update_meta ||= true
             end
-            order_flow_session_id = @current_order.flow_data['session_id']
-            order_session_expired = @current_order.flow_data['session_expires_at']
-            flow_io_session_id = session['_f60_session']
-            flow_io_session_expires = session['_f60_expires_at']
-            if flow_io_session_id.present?
-              if order_flow_session_id != flow_io_session_id &&
-                 order_session_expired&.to_datetime.to_i < flow_io_session_expires&.to_datetime.to_i
-                @current_order.flow_data['session_id'] = flow_io_session_id
-                @current_order.flow_data['session_expires_at'] = flow_io_session_expires
-                @current_order.flow_data['checkout_token'] = nil
-                update_meta ||= true
-              end
-            elsif order_flow_session_id.present?
-              session['_f60_session'] = order_flow_session_id
-              session['_f60_expires_at'] = order_session_expired
-            end
           end
 
           if @current_order.new_record?

data/app/models/spree/address_decorator.rb

@@ -11,7 +11,7 @@ module Spree
         address2: address_data['streets'][1],
         zipcode: address_data['postal'],
         city: address_data['city'],
-        state_name: address_data['province'] || 'something',
+        state_name: address_data['province'],
         country: Spree::Country.find_by(iso3: address_data['country'])
       }
     end

data/app/models/spree/calculator/flow_io.rb

@@ -32,7 +32,7 @@ module Spree
 
       def can_calculate_tax?(order)
         return false if order.flow_data.blank?
-        return false if %w[cart address delivery].include?(order.state)
+        return false if %w[cart address].include?(order.state)
 
         true
       end

data/app/models/spree/flow_io_credit_card_decorator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Spree
+  module FlowIoCreditCardDecorator
+    def self.prepended(base)
+      base.serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
+
+      base.store_accessor :meta, :flow_data
+    end
+
+    def push_authorization(auth_hash)
+      self.flow_data ||= {}
+      flow_data['authorizations'] ||= []
+      card_authorizations = flow_data['authorizations']
+      card_authorizations.delete_if { |ca| ca['id'] == auth_hash['id'] }
+      card_authorizations << auth_hash
+    end
+
+    Spree::CreditCard.prepend(self) if Spree::CreditCard.included_modules.exclude?(self)
+  end
+end

data/app/models/spree/{order_decorator.rb → flow_io_order_decorator.rb}

@@ -1,44 +1,32 @@
 # frozen_string_literal: true
 
-# `:display_total` modifications to display total prices beside Spree default. Example: https://i.imgur.com/7v2ix2G.png
-module Spree # rubocop:disable Metrics/ModuleLength
+module Spree
   # Added flow specific methods to Spree::Order
-  Order.class_eval do
-    serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
+  module FlowIoOrderDecorator
+    def self.included(base)
+      base.serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
 
-    store_accessor :meta, :flow_data
-
-    before_save :sync_to_flow_io
-    after_touch :sync_to_flow_io
+      base.store_accessor :meta, :flow_data
+    end
 
     def flow_tax_cache_key
       [number, 'flowcommerce', 'allocation', line_items.sum(:quantity)].join('-')
     end
 
-    def sync_to_flow_io
-      return unless zone&.flow_io_active_experience? && state == 'cart' && line_items.size > 0
-
-      flow_io_order = FlowcommerceSpree::OrderSync.new(order: self)
-      flow_io_order.build_flow_request
-      flow_io_order.synchronize! if flow_data['digest'] != flow_io_order.digest
-    end
-
     def display_total
-      price = FlowcommerceSpree::Api.format_default_price total
-      price += " (#{flow_total})" if flow_order
-      price.html_safe
+      return unless flow_data&.[]('order')
+
+      Spree::Money.new(flow_io_total_amount, currency: currency)
     end
 
     def flow_order
-      return unless flow_data&.[]('order')
-
-      Hashie::Mash.new flow_data['order']
+      flow_data&.[]('order')
     end
 
     # accepts line item, usually called from views
     def flow_line_item_price(line_item, total = false)
-      result = if flow_order
-                 item = flow_order.lines&.find { |el| el['item_number'] == line_item.variant.sku }
+      result = if (order = flow_order)
+                 item = order['lines']&.find { |el| el['item_number'] == line_item.variant.sku }
 
                  return 'n/a' unless item
 
@@ -95,10 +83,8 @@ module Spree # rubocop:disable Metrics/ModuleLength
     end
 
     # shows localized total, if possible. if not, fall back to Spree default
-    def flow_total
-      # r flow_order.total.label
-      price = flow_order&.total&.label
-      price || FlowcommerceSpree::Api.format_default_price(total)
+    def flow_io_total_amount
+      flow_data&.dig('order', 'total', 'amount')&.to_d
     end
 
     def flow_experience
@@ -108,10 +94,6 @@ module Spree # rubocop:disable Metrics/ModuleLength
       model.new ENV.fetch('FLOW_BASE_COUNTRY')
     end
 
-    def flow_io_checkout_token
-      flow_data&.[]('checkout_token')
-    end
-
     def flow_io_experience_key
       flow_data&.[]('exp')
     end
@@ -124,19 +106,10 @@ module Spree # rubocop:disable Metrics/ModuleLength
       flow_data&.dig('order', 'id')
     end
 
-    def flow_io_session_expires_at
-      flow_data&.[]('session_expires_at')&.to_datetime
-    end
-
     def flow_io_attributes
       flow_data&.dig('order', 'attributes') || {}
     end
 
-    def add_flow_checkout_token(token)
-      self.flow_data ||= {}
-      self.flow_data['checkout_token'] = token
-    end
-
     def flow_io_attribute_add(attr_key, value)
       self.flow_data['order'] ||= {}
       self.flow_data['order']['attributes'] ||= {}
@@ -153,35 +126,26 @@ module Spree # rubocop:disable Metrics/ModuleLength
       flow_data&.dig('order', 'attributes', 'user_uuid')
     end
 
-    def checkout_url
-      FlowcommerceSpree::OrderSync.new(order: self).synchronize!
-
-      checkout_token = flow_io_checkout_token
-      return "https://checkout.flow.io/tokens/#{checkout_token}" if checkout_token
+    def flow_io_captures
+      flow_data&.[]('captures')
     end
 
-    # clear invalid zero amount payments. Solidus bug?
-    def clear_zero_amount_payments!
-      # class attribute that can be set to true
-      return unless Flow::Order.clear_zero_amount_payments
-
-      payments.where(amount: 0, state: %w[invalid processing pending]).map(&:destroy)
-    end
+    def flow_io_captures_sum
+      captures_sum = 0
+      flow_data&.[]('captures')&.each do |c|
+        next if c['status'] != 'succeeded'
 
-    def flow_order_authorized?
-      flow_data&.[]('authorization') ? true : false
+        captures_sum += c['amount']
+      end
+      captures_sum.to_d
     end
 
-    def flow_order_captured?
-      flow_data['capture'] ? true : false
+    def flow_io_balance_amount
+      flow_data&.dig('order', 'balance', 'amount')&.to_d
     end
 
-    # completes order and sets all states to finalized and complete
-    # used when we have confirmed capture from Flow API or PayPal
-    def flow_finalize!
-      finalize! unless state == 'complete'
-      update_column :payment_state, 'paid' if payment_state != 'paid'
-      update_column :state, 'complete'     if state != 'complete'
+    def flow_io_payments
+      flow_data.dig('order', 'payments')
     end
 
     def flow_payment_method
@@ -228,17 +192,19 @@ module Spree # rubocop:disable Metrics/ModuleLength
       s_address = flow_ship_address
 
       if s_address&.changes&.any?
-        s_address.save
+        s_address.save!
         address_attributes[:ship_address_id] = s_address.id unless ship_address_id
       end
 
       b_address = flow_bill_address
       if b_address&.changes&.any?
-        b_address.save
+        b_address.save!
         address_attributes[:bill_address_id] = b_address.id unless bill_address_id
       end
 
       address_attributes
     end
+
+    Spree::Order.include(self) if Spree::Order.included_modules.exclude?(self)
   end
 end

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

@@ -5,6 +5,8 @@
 module Spree
   class Gateway
     class FlowIo < Gateway
+      REFUND_SUCCESS = 'succeeded'
+
       def provider_class
         self.class
       end
@@ -23,7 +25,7 @@ module Spree
       end
 
       def method_type
-        'gateway'
+        'flow_io_gateway'
       end
 
       def preferences
@@ -40,34 +42,29 @@ module Spree
         order.cc_authorization
       end
 
-      def capture(_amount, _payment_method, options = {})
-        order = load_order options
-        order.cc_capture
-      end
-
-      def purchase(_amount, _payment_method, options = {})
-        order = load_order options
-        flow_auth = order.cc_authorization
-
-        if flow_auth.success?
-          order.cc_capture
-        else
-          flow_auth
-        end
+      def refund(payment, amount, _options = {})
+        request_refund_store_result(payment.order, amount)
+      rescue StandardError => e
+        ActiveMerchant::Billing::Response.new(false, e.to_s, {}, {})
       end
 
-      def refund(_money, _authorization_key, options = {})
-        order = load_order options
-        order.cc_refund
+      def cancel(authorization)
+        original_payment = Spree::Payment.find_by(response_code: authorization)
+        request_refund_store_result(original_payment.order, original_payment.amount)
+      rescue StandardError => e
+        ActiveMerchant::Billing::Response.new(false, e.to_s, {}, {})
       end
 
-      def void(money, authorization_key, options = {})
-        # binding.pry
+      def void(authorization_id, _source, options = {})
+        amount = (options[:subtotal] + options[:shipping]) * 0.01
+        reversal_form = Io::Flow::V0::Models::ReversalForm.new(key: options[:order_id],
+                                                               authorization_id: authorization_id,
+                                                               amount: amount,
+                                                               currency: options[:currency])
+        FlowcommerceSpree.client.reversals.post(FlowcommerceSpree::ORGANIZATION, reversal_form)
       end
 
       def create_profile(payment)
-        # binding.pry
-
         # payment.order.state
         @credit_card = payment.source
 
@@ -77,12 +74,52 @@ module Spree
 
       private
 
+      def request_refund_store_result(order, amount)
+        refund_form = Io::Flow::V0::Models::RefundForm.new(order_number: order.number,
+                                                           amount: amount,
+                                                           currency: order.currency)
+        response = FlowcommerceSpree.client.refunds.post(FlowcommerceSpree::ORGANIZATION, refund_form)
+        response_status = response.status.value
+        if response_status == REFUND_SUCCESS
+          add_refund_to_order(response, order)
+          map_refund_to_payment(response, order)
+          ActiveMerchant::Billing::Response.new(true, REFUND_SUCCESS, {}, {})
+        else
+          msg = "Partial refund fail. Details: #{response_status}"
+          ActiveMerchant::Billing::Response.new(false, msg, {}, {})
+        end
+      end
+
+      def add_refund_to_order(response, order)
+        order.flow_data ||= {}
+        order.flow_data['refunds'] ||= []
+        order_refunds = order.flow_data['refunds']
+        order_refunds.delete_if { |r| r['id'] == response.id }
+        order_refunds << response.to_hash
+        order.update_column(:meta, order.meta.to_json)
+      end
+
+      def map_refund_to_payment(response, order)
+        original_payment = Spree::Payment.find_by(response_code: response.authorization.id)
+        payment = order.payments.create!(state: 'completed',
+                                         response_code: response.authorization.id,
+                                         payment_method_id: original_payment&.payment_method_id,
+                                         amount: - response.amount,
+                                         source_id: original_payment&.source_id,
+                                         source_type: original_payment&.source_type)
+
+        # For now this additional update is overwriting the generated identifier with flow.io payment identifier.
+        # TODO: Check and possibly refactor in Spree 3.0, where the `before_create :set_unique_identifier`
+        # has been removed.
+        payment.update_column(:identifier, response.id)
+      end
+
       # hard inject Flow as payment method unless defined
       def profile_ensure_payment_method_is_present!
         return if @credit_card.payment_method_id
 
-        flow_payment = Spree::PaymentMethod.where(active: true, type: 'Spree::Gateway::FlowIo').first
-        @credit_card.payment_method_id = flow_payment.id if flow_payment
+        flow_payment_method = Spree::PaymentMethod.find_by(active: true, type: 'Spree::Gateway::FlowIo')
+        @credit_card.payment_method_id = flow_payment_method.id if flow_payment_method
       end
 
       # create payment profile with Flow and tokenize Credit Card