flowcommerce_spree 0.0.2 → 0.0.7

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/serializers/api/v2/order_serializer_decorator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+Api::V2::OrderSerializer.class_eval do
+  attribute :duty_included, if: proc { object.flow_io_attributes.present? }
+  attribute :vat_included, if: proc { object.flow_io_attributes.present? }
+
+  def duty_included
+    flow_io_order_attributes&.[]('duty') == 'included'
+  end
+
+  def vat_included
+    flow_io_order_attributes&.[]('vat') == 'included'
+  end
+
+  private
+
+  def flow_io_order_attributes
+    @flow_io_order_attributes ||= Oj.load(object.flow_io_attributes['pricing_key'])
+  end
+end

data/app/services/flowcommerce_spree/import_experience_items.rb

@@ -13,7 +13,7 @@ module FlowcommerceSpree
       items      = []
       total = 0
 
-      while offset == 0 || items.length == 100
+      while offset == 0 || items.length != 0
         # show current list size
         @logger.info "\nGetting items: #{@experience_key.green}, rows #{offset} - #{offset + page_size}"
 

data/app/services/flowcommerce_spree/order_sync.rb

@@ -2,196 +2,118 @@
 
 module FlowcommerceSpree
   # represents flow.io order syncing service
-  # for easy integration we are currently passing:
-  # - flow experience
-  # - spree order
-  # - current customer, present as  @current_spree_user controller instance variable
-  #
-  # example:
-  #  flow_order = FlowcommerceSpree::OrderSync.new    # init flow-order object
-  #    order: Spree::Order.last,
-  #    experience: @flow_session.experience
-  #    customer: Spree::User.last
-  #  flow_order.build_flow_request           # builds json body to be posted to flow.io api
-  #  flow_order.synchronize!                 # sends order to flow
   class OrderSync
     FLOW_CENTER = 'default'
 
-    attr_reader :digest, :order, :response
+    attr_reader :order, :response
 
-    class << self
-      def clear_cache(order)
-        return unless order.flow_data['order']
+    # @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?
 
-        order.flow_data.delete('order')
-        order.update_column :meta, order.meta.to_json
-      end
-    end
-
-    def initialize(order:)
-      raise(ArgumentError, 'Experience not defined or not active') unless order.zone&.flow_io_active_experience?
-
-      @client = FlowcommerceSpree.client(session_id: order.flow_data['session_id'])
       @experience = order.flow_io_experience_key
-      @order      = order
-      @customer   = order.user
-      @items      = []
+      @flow_session_id = flow_session_id
+      @order = order
+      @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!
-      sync_body!
-      check_state!
-      write_response_in_cache
-      @response
-    end
+      return unless @order.state == 'cart' && @order.line_items.size > 0
 
-    def error
-      @response['messages'].join(', ')
-    end
+      sync_body!
+      write_response_to_order
 
-    def error_code
-      @response['code']
+      @order.update_columns(total: @order.total, meta: @order.meta.to_json)
+      refresh_checkout_token
     end
 
     def error?
       @response&.[]('code') && @response&.[]('messages') ? true : false
     end
 
-    def delivery
-      deliveries.select { |el| el[:active] }.first
-    end
-
-    # delivery methods are defined in flow console
-    def deliveries
-      # if we have erorr with an order, but still using this method
-      return [] unless @order.flow_order
-
-      @order.flow_data ||= {}
-
-      delivery_list = @order.flow_order['deliveries'][0]['options']
-      delivery_list = delivery_list.map do |opts|
-        name = opts['tier']['name']
-
-        # add original Flow ID
-        # name        += ' (%s)' % opts['tier']['strategy'] if opts['tier']['strategy']
-
-        selection_id = opts['id']
-
-        { id: selection_id,
-          price: { label: opts['price']['label'] },
-          active: @order.flow_order['selections'].include?(selection_id),
-          name: name }
-      end.to_a
-
-      # make first one active unless we have active element
-      delivery_list.first[:active] = true unless delivery_list.select { |el| el[:active] }.first
-
-      delivery_list
-    end
-
-    def total_price
-      @order.flow_total
-    end
-
-    def delivered_duty
-      # paid is default
-      @order.flow_data['delivered_duty'] || ::Io::Flow::V0::Models::DeliveredDuty.paid.value
-    end
+    private
 
     # builds object that can be sent to api.flow.io to sync order data
     def build_flow_request
-      @order.line_items.each { |line_item| add_item(line_item) }
+      @opts = { experience: @experience, expand: ['experience'] }
+      @body = { items: @order.line_items.map { |line_item| add_item(line_item) } }
 
-      @opts = {}
-      @opts[:experience]   = @experience
-      @opts[:expand]       = ['experience']
+      try_to_add_customer
 
-      @body = { items: @items, number: @order.number }
+      return unless (flow_data = @order.flow_data['order'])
 
-      add_customer if @customer
+      @body[:selections] = flow_data['selections'].presence
+      @body[:delivered_duty] = flow_data['delivered_duty'].presence
+      @body[:attributes] = flow_data['attributes'].presence
 
-      if (flow_data = @order.flow_data['order'])
-        @body[:selections] = flow_data['selections'].presence
-        @body[:delivered_duty] = flow_data['delivered_duty'].presence
-        @body[:attributes] = flow_data['attributes'].presence
+      # discount on full order is applied
+      @body[:discount] = { amount: @order.adjustment_total, currency: @order.currency } if @order.adjustment_total != 0
+    end
 
-        if @order.adjustment_total != 0
-          # discount on full order is applied
-          @body[:discount] = { amount: @order.adjustment_total, currency: @order.currency }
-        end
-      end
+    def refresh_checkout_token
+      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}"
+      @order.flow_io_attribute_add('flow_return_url', confirmation_url)
+      @order.flow_io_attribute_add('checkout_continue_shopping_url', root_url)
 
-      # calculate digest body and cache it
-      @digest = Digest::SHA1.hexdigest(@opts.to_json + @body.to_json)
+      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
 
-    private
-
     # if customer is defined, add customer info
     # it is possible to have order in Spree without customer info (new guest session)
-    def add_customer
-      return unless @customer
-
-      address = @customer.ship_address
-      # address = nil
-      if address
-        @body[:customer] = { name: { first: address.firstname,
-                                     last: address.lastname },
-                             email: @customer.email,
-                             number: @customer.flow_number,
-                             phone: address.phone }
-
-        streets = []
-        streets.push address.address1 unless address.address1.blank?
-        streets.push address.address2 unless address.address2.blank?
-
-        @body[:destination] = { streets: streets,
-                                city: address.city,
-                                province: address.state_name,
-                                postal: address.zipcode,
-                                country: (address.country.iso3 || 'USA'),
-                                contact: @body[:customer] }
-
-        @body[:destination].delete_if { |_k, v| v.nil? }
-      end
+    def try_to_add_customer
+      return unless (customer = @order.user)
 
-      @body
-    end
+      address = nil
+      customer_ship_address = customer.ship_address
+      address = customer_ship_address if customer_ship_address&.country&.iso3 == @order.zone.flow_io_experience_country
 
-    def sync_body!
-      build_flow_request if @body.blank?
+      customer_profile = customer.user_profile
+      unless address
+        user_profile_address = customer_profile&.address
+        address = user_profile_address if user_profile_address&.country&.iso3 == @order.zone.flow_io_experience_country
+      end
 
-      @use_get = false
+      @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 }
 
-      # use get if order is completed and closed
-      @use_get = true if @order.state == 'complete'
+      add_customer_address(address) if address
+    end
 
-      # use get if local digest hash check said there is no change
-      @use_get ||= true if @order.flow_data['digest'] == @digest
+    def add_customer_address(address)
+      streets = []
+      streets.push address.address1 if address.address1.present?
+      streets.push address.address2 if address.address2.present?
 
-      # do not use get if there is no local order cache
-      @use_get = false unless @order.flow_data['order']
+      @body[:destination] = { streets: streets,
+                              city: address.city,
+                              province: address.state_name,
+                              postal: address.zipcode,
+                              country: (address.country&.iso3 || ''),
+                              contact: @body[:customer] }
 
-      if @use_get
-        @response ||= FlowcommerceSpree::Api.run :get, "/:organization/orders/#{@body[:number]}", expand: 'experience'
-      else
-        @response = @client.orders.put_by_number(FlowcommerceSpree::ORGANIZATION, @order.number,
-                                                 Io::Flow::V0::Models::OrderPutForm.new(@body), @opts).to_hash
-      end
+      @body[:destination].delete_if { |_k, v| v.nil? }
     end
 
-    def check_state!
-      # authorize if not authorized
-      # if !@order.flow_order_authorized?
-
-      # authorize payment on complete, unless authorized
-      if @order.state == 'complete' && !@order.flow_order_authorized?
-        simple_gateway = Flow::SimpleGateway.new(@order)
-        simple_gateway.cc_authorization
-      end
+    def sync_body!
+      build_flow_request
 
-      @order.flow_finalize! if @order.flow_order_authorized? && @order.state != 'complete'
+      @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)
@@ -199,33 +121,19 @@ module FlowcommerceSpree
       price_root = variant.flow_data&.dig('exp', @experience, 'prices')&.[](0) || {}
 
       # create flow order line item
-      item = { center: FLOW_CENTER,
-               number: variant.sku,
-               quantity: line_item.quantity,
-               price: { amount: price_root['amount'] || variant.cost_price,
-                        currency: price_root['currency'] || variant.cost_currency } }
-
-      @items.push item
+      { center: FLOW_CENTER,
+        number: variant.sku,
+        quantity: line_item.quantity,
+        price: { amount: price_root['amount'] || variant.cost_price,
+                 currency: price_root['currency'] || variant.cost_currency } }
     end
 
-    # set cache for total order ammount
-    # written in flow_data field inside spree_orders table
-    def write_response_in_cache
-      if !@response || error?
-        @order.flow_data.delete('digest')
-        @order.flow_data.delete('order')
-      else
-        response_total = @response.dig('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 == cache_total
-
-        # update local order
-        @order.flow_data.merge!('digest' => @digest, 'order' => @response.to_hash)
-      end
+    def write_response_to_order
+      return @order.flow_data.delete('order') if !@response || error?
 
-      @order.update_column(:meta, @order.meta.to_json)
+      # 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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class OrderUpdater
+    def initialize(order:)
+      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
+      @client = FlowcommerceSpree.client
+    end
+
+    def upsert_data(flow_io_order = nil)
+      return if @order.state == 'complete'
+
+      flow_io_order ||= @client.orders.get_by_number(FlowcommerceSpree::ORGANIZATION, @order.number).to_hash
+
+      @order.flow_data['order'] = flow_io_order
+      return if @order.flow_data.dig('order', 'submitted_at').blank?
+
+      attrs_to_update = { meta: @order.meta.to_json, email: @order.flow_customer_email, payment_state: 'pending' }
+      attrs_to_update.merge!(@order.prepare_flow_addresses)
+      @order.update_columns(attrs_to_update)
+      @order.state = 'delivery'
+      @order.save!
+      @order.create_proposed_shipments
+      @order.shipment.update_amounts
+      @order.line_items.each(&:store_ets)
+      @order.charge_taxes
+
+      @order.state = 'payment'
+      @order.save!
+    end
+
+    def finalize_order
+      @order.reload
+      @order.finalize!
+      @order.update_totals
+      @order.save
+      @order.after_completed_order
+    end
+
+    def complete_checkout
+      upsert_data
+      map_payments_to_spree
+      finalize_order if @order.state == 'complete'
+    end
+
+    def map_payments_to_spree
+      @order.flow_io_payments&.each do |p|
+        payment =
+          @order.payments.find_or_initialize_by(response_code: p['reference'], payment_method_id: payment_method_id)
+        next unless payment.new_record?
+
+        payment.amount = p.dig('total', 'amount')
+        payment.pend
+
+        # 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, p['id'])
+      end
+
+      return if @order.payments.sum(:amount) < @order.amount || @order.state == 'complete'
+
+      @order.state = 'confirm'
+      @order.save!
+      @order.state = 'complete'
+      @order.save!
+    end
+
+    def payment_method_id
+      @payment_method_id ||= Spree::PaymentMethod.find_by(active: true, type: 'Spree::Gateway::FlowIo').id
+    end
+  end
+end

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