flowcommerce_spree 0.0.4 → 0.0.9

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

@@ -21,7 +21,7 @@ module Spree
       end
 
       def payment_profiles_supported?
-        true
+        false
       end
 
       def method_type
@@ -43,14 +43,18 @@ module Spree
       end
 
       def refund(payment, amount, _options = {})
-        request_refund_store_result(payment.order, amount)
+        response = request_refund_store_result(payment.order, amount)
+        map_refund_to_payment(response, payment.order) if response.success?
+        response
       rescue StandardError => e
         ActiveMerchant::Billing::Response.new(false, e.to_s, {}, {})
       end
 
       def cancel(authorization)
         original_payment = Spree::Payment.find_by(response_code: authorization)
-        request_refund_store_result(original_payment.order, original_payment.amount)
+        response = request_refund_store_result(original_payment.order, original_payment.amount)
+        map_refund_to_payment(response, original_payment.order) if response.success?
+        response
       rescue StandardError => e
         ActiveMerchant::Billing::Response.new(false, e.to_s, {}, {})
       end
@@ -72,6 +76,12 @@ module Spree
         create_flow_cc_profile!
       end
 
+      def credit(payment, credit_amount)
+        request_refund_store_result(payment.order, credit_amount)
+      rescue StandardError => e
+        ActiveMerchant::Billing::Response.new(false, e.to_s, {}, {})
+      end
+
       private
 
       def request_refund_store_result(order, amount)
@@ -82,8 +92,10 @@ module Spree
         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, {}, {})
+          ActiveMerchant::Billing::Response.new(true,
+                                                REFUND_SUCCESS,
+                                                response.to_hash,
+                                                authorization: response.authorization.id)
         else
           msg = "Partial refund fail. Details: #{response_status}"
           ActiveMerchant::Billing::Response.new(false, msg, {}, {})
@@ -100,18 +112,17 @@ module Spree
       end
 
       def map_refund_to_payment(response, order)
-        original_payment = Spree::Payment.find_by(response_code: response.authorization.id)
+        original_payment = Spree::Payment.find_by(response_code: response.authorization)
         payment = order.payments.create!(state: 'completed',
-                                         response_code: response.authorization.id,
+                                         response_code: response.authorization,
                                          payment_method_id: original_payment&.payment_method_id,
-                                         amount: - response.amount,
-                                         source_id: original_payment&.source_id,
-                                         source_type: original_payment&.source_type)
+                                         amount: - response.params['amount'].to_f,
+                                         source: original_payment)
 
         # 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)
+        payment.update_column(:identifier, response.params['id'])
       end
 
       # hard inject Flow as payment method unless defined

data/app/models/spree/zones/flow_io_product_zone_decorator.rb

@@ -28,6 +28,10 @@ module Spree
         flow_data&.[]('key').present? && flow_data['status'] == 'active'
       end
 
+      def flow_io_active_or_archiving_experience?
+        flow_data&.[]('key').present? && %w[active archiving].include?(flow_data['status'])
+      end
+
       def update_on_flow; end
 
       def remove_on_flow_io

data/app/overrides/spree/admin/order_sidebar_summary_flow_link.rb

@@ -0,0 +1,13 @@
+Deface::Override.new(
+  virtual_path: 'spree/admin/shared/_order_tabs',
+  name: 'spree_admin_order_additional_information_flow_message',
+  insert_top: '.additional-info',
+  text: '
+    <% if FlowcommerceSpree::ORGANIZATION.present? && @order.flow_order.present? %>
+      <div style="text-align: center">
+        <%= link_to "See Flow Order",
+                    "https://console.flow.io/#{FlowcommerceSpree::ORGANIZATION}/orders/#{@order.number}",
+                    target: "_blank", class: "button" %>
+      </div>
+    <% end %>'
+)

data/app/overrides/spree/admin/products/order_price_flow_message.rb

@@ -0,0 +1,9 @@
+Deface::Override.new(
+  virtual_path: 'spree/admin/prices/index',
+  name: 'spree_admin_prices_flow_mesage',
+  insert_top: '.no-border-top',
+  text: "
+  <div class='spree-admin-info' >
+    To check localized pricing, please click <a href='#{"https://console.flow.io/#{ENV['FLOW_ORGANIZATION']}/price-books"}' target='_blank'>here</a>.
+  </div>"
+)

data/app/services/flowcommerce_spree/import_experience_items.rb

@@ -33,14 +33,6 @@ module FlowcommerceSpree
           item_hash = item.to_hash
           next unless (variant = Spree::Variant.find_by(sku: item_hash.delete(:number)))
 
-          status_in_experience = item_hash.dig(:local, :status)
-
-          if status_in_experience != 'included'
-            log_str << "[#{status_in_experience.red}]:"
-          else # If at least a variant is included in experience, include the product too
-            adjust_product_zone(variant)
-          end
-
           variant.flow_import_item(item_hash, experience_key: @experience_key)
 
           log_str << "#{variant.sku}, "
@@ -60,17 +52,5 @@ module FlowcommerceSpree
       @organization = organization
       @zone = zone
     end
-
-    def adjust_product_zone(variant)
-      return unless (product = variant.product)
-
-      zone_ids = product.zone_ids || []
-      zone_id_string = @zone.id.to_s
-      return if zone_ids.include?(zone_id_string)
-
-      zone_ids << zone_id_string
-      product.zone_ids = zone_ids
-      product.update_columns(meta: product.meta.to_json)
-    end
   end
 end

data/app/services/flowcommerce_spree/import_item.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  # A service object to import the data for product variants belonging to a flow.io Experience
+  class ImportItem
+    def self.run(variant, client: FlowcommerceSpree.client, organization: ORGANIZATION)
+      new(variant, client: client, organization: organization).run
+    end
+
+    def run
+      @client.experiences.get(@organization, status: 'active').each do |experience|
+        experience_key = experience.key
+        zone = Spree::Zones::Product.find_by(name: experience_key.titleize)
+        next unless zone
+
+        import_data(zone)
+      end
+    end
+
+    private
+
+    def initialize(variant, client:, organization:)
+      @client = client
+      @logger = client.instance_variable_get(:@http_handler).logger
+      @organization = organization
+      @variant = variant
+    end
+
+    def import_data(zone)
+      experience_key = zone.flow_io_experience
+      item = begin
+               @client.experiences.get_items_by_number(@organization, @variant.sku, experience: experience_key)
+             rescue Io::Flow::V0::HttpClient::PreconditionException, Io::Flow::V0::HttpClient::ServerError => e
+               @logger.info "flow.io API error: #{e.message}"
+             end
+      return unless item
+
+      item_hash = item.to_hash
+
+      @variant.flow_import_item(item_hash, experience_key: @experience_key)
+
+      @logger.info "[#{@variant.sku}][#{experience_key}] Variant experience imported successfully."
+    end
+  end
+end

data/app/services/flowcommerce_spree/order_sync.rb

@@ -2,58 +2,40 @@
 
 module FlowcommerceSpree
   # represents flow.io order syncing service
-  # for easy integration we are currently passing:
-  # - flow experience
-  # - spree order
-  # - current customer, if present as  @order.user
-  #
-  # example:
-  #  flow_order = FlowcommerceSpree::OrderSync.new    # init flow-order object
-  #    order: Spree::Order.last,
-  #    experience: @flow_session.experience
-  #    customer: @order.user
-  #  flow_order.build_flow_request           # builds json body to be posted to flow.io api
-  #  flow_order.synchronize!                 # sends order to flow
-  class OrderSync # rubocop:disable Metrics/ClassLength
+  class OrderSync
     FLOW_CENTER = 'default'
 
     attr_reader :order, :response
 
-    delegate :url_helpers, to: 'Rails.application.routes'
-
+    # @param [Object] order
+    # @param [String] flow_session_id
     def initialize(order:, flow_session_id:)
-      raise(ArgumentError, 'Experience not defined or not active') unless order.zone&.flow_io_active_experience?
+      raise(ArgumentError, 'Experience not defined or not active') unless order&.zone&.flow_io_active_experience?
 
       @experience = order.flow_io_experience_key
       @flow_session_id = flow_session_id
       @order = order
-      @client = FlowcommerceSpree.client(session_id: flow_session_id)
+      @client = FlowcommerceSpree.client(default_headers: { "Authorization": "Session #{flow_session_id}" },
+                                         authorization: nil)
     end
 
     # helper method to send complete order from Spree to flow.io
     def synchronize!
-      return unless @order.zone&.flow_io_active_experience? && @order.state == 'cart' && @order.line_items.size > 0
+      return unless @order.state == 'cart' && @order.line_items.size > 0
 
       sync_body!
-      write_response_in_cache
+      write_response_to_order
 
       @order.update_columns(total: @order.total, meta: @order.meta.to_json)
       refresh_checkout_token
-      @checkout_token
-    end
-
-    def error
-      @response['messages'].join(', ')
-    end
-
-    def error_code
-      @response['code']
     end
 
     def error?
       @response&.[]('code') && @response&.[]('messages') ? true : false
     end
 
+    private
+
     # builds object that can be sent to api.flow.io to sync order data
     def build_flow_request
       @opts = { experience: @experience, expand: ['experience'] }
@@ -71,24 +53,21 @@ module FlowcommerceSpree
       @body[:discount] = { amount: @order.adjustment_total, currency: @order.currency } if @order.adjustment_total != 0
     end
 
-    private
-
     def refresh_checkout_token
-      root_url = url_helpers.root_url
+      root_url = Rails.application.routes.url_helpers.root_url
       order_number = @order.number
       confirmation_url = "#{root_url}flow/order-completed?order=#{order_number}&t=#{@order.guest_token}"
-      @checkout_token = FlowcommerceSpree.client.checkout_tokens.post_checkout_and_tokens_by_organization(
-        FlowcommerceSpree::ORGANIZATION,
-        discriminator: 'checkout_token_reference_form',
-        order_number: order_number,
-        session_id: @flow_session_id,
-        urls: { continue_shopping: root_url,
-                confirmation: confirmation_url,
-                invalid_checkout: root_url }
-      )&.id
-
       @order.flow_io_attribute_add('flow_return_url', confirmation_url)
       @order.flow_io_attribute_add('checkout_continue_shopping_url', root_url)
+
+      FlowcommerceSpree.client.checkout_tokens.post_checkout_and_tokens_by_organization(
+        FlowcommerceSpree::ORGANIZATION, discriminator: 'checkout_token_reference_form',
+                                         order_number: order_number,
+                                         session_id: @flow_session_id,
+                                         urls: { continue_shopping: root_url,
+                                                 confirmation: confirmation_url,
+                                                 invalid_checkout: root_url }
+      )&.id
     end
 
     # if customer is defined, add customer info
@@ -100,13 +79,14 @@ module FlowcommerceSpree
       customer_ship_address = customer.ship_address
       address = customer_ship_address if customer_ship_address&.country&.iso3 == @order.zone.flow_io_experience_country
 
+      customer_profile = customer.user_profile
       unless address
-        user_profile_address = customer.user_profile&.address
+        user_profile_address = customer_profile&.address
         address = user_profile_address if user_profile_address&.country&.iso3 == @order.zone.flow_io_experience_country
       end
 
-      @body[:customer] = { name: { first: address&.firstname,
-                                   last: address&.lastname },
+      @body[:customer] = { name: { first: address&.firstname || customer_profile&.first_name,
+                                   last: address&.lastname || customer_profile&.last_name },
                            email: customer.email,
                            number: customer.flow_number,
                            phone: address&.phone }
@@ -116,14 +96,14 @@ module FlowcommerceSpree
 
     def add_customer_address(address)
       streets = []
-      streets.push address.address1 if address&.address1.present?
-      streets.push address.address2 if address&.address2.present?
+      streets.push address.address1 if address.address1.present?
+      streets.push address.address2 if address.address2.present?
 
       @body[:destination] = { streets: streets,
-                              city: address&.city,
-                              province: address&.state_name,
-                              postal: address&.zipcode,
-                              country: (address&.country&.iso3 || ''),
+                              city: address.city,
+                              province: address.state_name,
+                              postal: address.zipcode,
+                              country: (address.country&.iso3 || ''),
                               contact: @body[:customer] }
 
       @body[:destination].delete_if { |_k, v| v.nil? }
@@ -132,20 +112,8 @@ module FlowcommerceSpree
     def sync_body!
       build_flow_request
 
-      @use_get = false
-
-      # use get if order is completed and closed
-      @use_get = true if @order.flow_data.dig('order', 'submitted_at').present? || @order.state == 'complete'
-
-      # do not use get if there is no local order cache
-      @use_get = false unless @order.flow_data['order']
-
-      if @use_get
-        @response ||= @client.orders.get_by_number(ORGANIZATION, @order.number).to_hash
-      else
-        @response = @client.orders.put_by_number(ORGANIZATION, @order.number,
-                                                 Io::Flow::V0::Models::OrderPutForm.new(@body), @opts).to_hash
-      end
+      @response = @client.orders.put_by_number(ORGANIZATION, @order.number,
+                                               Io::Flow::V0::Models::OrderPutForm.new(@body), @opts).to_hash
     end
 
     def add_item(line_item)
@@ -156,27 +124,16 @@ module FlowcommerceSpree
       { center: FLOW_CENTER,
         number: variant.sku,
         quantity: line_item.quantity,
-        price: { amount: price_root['amount'] || variant.cost_price,
+        price: { amount: price_root['amount'] || variant.price,
                  currency: price_root['currency'] || variant.cost_currency } }
     end
 
-    # set cache for total order amount
-    # written in flow_data field inside spree_orders table
-    def write_response_in_cache
-      if !@response || error?
-        @order.flow_data.delete('order')
-      else
-        response_total = @response[:total]
-        response_total_label = response_total&.[](:label)
-        cache_total = @order.flow_data.dig('order', 'total', 'label')
-
-        # return if total is not changed, no products removed or added
-        return if @use_get && response_total_label == cache_total
-
-        # update local order
-        @order.total = response_total&.[](:amount)
-        @order.flow_data.merge!('order' => @response)
-      end
+    def write_response_to_order
+      return @order.flow_data.delete('order') if !@response || error?
+
+      # update local order
+      @order.total = @response[:total]&.[](:amount)
+      @order.flow_data.merge!('order' => @response)
     end
   end
 end

data/app/services/flowcommerce_spree/order_updater.rb

@@ -3,7 +3,9 @@
 module FlowcommerceSpree
   class OrderUpdater
     def initialize(order:)
-      raise(ArgumentError, 'Experience not defined or not active') unless order&.zone&.flow_io_active_experience?
+      unless order&.zone&.flow_io_active_or_archiving_experience?
+        raise(ArgumentError, 'Experience not defined or not active')
+      end
 
       @experience = order.flow_io_experience_key
       @order = order

data/app/services/flowcommerce_spree/webhooks/capture_upserted_v2.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  module Webhooks
+    class CaptureUpsertedV2
+      attr_reader :errors
+      alias full_messages errors
+
+      def self.process(data)
+        new(data).process
+      end
+
+      def initialize(data)
+        @data = data
+        @errors = []
+      end
+
+      def process
+        errors << { message: 'Capture param missing' } && (return self) unless (capture = @data['capture']&.to_hash)
+
+        order_number = capture.dig('authorization', 'order', 'number')
+        errors << { message: 'Order number param missing' } && (return self) unless order_number
+
+        if (order = Spree::Order.find_by(number: order_number))
+          upsert_order_captures(order, capture)
+          payments = order.flow_io_payments
+          map_payment_captures_to_spree(order, payments) if payments.present?
+          order
+        else
+          errors << { message: "Order #{order_number} not found" }
+          self
+        end
+      end
+
+      private
+
+      def upsert_order_captures(order, capture)
+        order.flow_data ||= {}
+        order.flow_data['captures'] ||= []
+        order_captures = order.flow_data['captures']
+        order_captures.delete_if { |c| c['id'] == capture['id'] }
+        order_captures << capture
+        order.update_column(:meta, order.meta.to_json)
+      end
+
+      def map_payment_captures_to_spree(order, payments)
+        order.flow_data['captures']&.each do |c|
+          next unless (payment = captured_payment(payments, c))
+
+          payment.capture_events.create!(amount: c['amount'], meta: { 'flow_data' => { 'id' => c['id'] } })
+          return if payment.completed? || payment.capture_events.sum(:amount) < payment.amount
+
+          payment.complete
+        end
+
+        return if order.completed?
+        return unless order.flow_io_captures_sum >= order.flow_io_total_amount && order.flow_io_balance_amount <= 0
+
+        FlowcommerceSpree::OrderUpdater.new(order: order).finalize_order
+      end
+
+      def captured_payment(flow_order_payments, capture)
+        return unless capture['status'] == 'succeeded'
+
+        auth = capture.dig('authorization', 'id')
+        return unless flow_order_payments&.find { |p| p['reference'] == auth }
+
+        return unless (payment = Spree::Payment.find_by(response_code: auth))
+
+        return if Spree::PaymentCaptureEvent.where("meta -> 'flow_data' ->> 'id' = ?", capture['id']).exists?
+
+        payment
+      end
+    end
+  end
+end