flowcommerce_spree 0.0.3 → 0.0.8

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

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  module Webhooks
+    class CardAuthorizationUpsertedV2
+      attr_reader :errors
+      alias full_messages errors
+
+      def self.process(data)
+        new(data).process
+      end
+
+      def initialize(data)
+        @data = data['authorization']&.to_hash
+        @data&.[]('method')&.delete('images')
+        @errors = []
+      end
+
+      def process
+        errors << { message: 'Authorization param missing' } && (return self) unless @data
+
+        errors << { message: 'Card param missing' } && (return self) unless (flow_io_card = @data.delete('card'))
+
+        if (order_number = @data.dig('order', 'number'))
+          if (order = Spree::Order.find_by(number: order_number))
+            card = upsert_card(flow_io_card, order)
+
+            order.payments.where(response_code: @data['id'])
+                 .update_all(source_id: card.id, source_type: 'Spree::CreditCard')
+
+            return card
+          else
+            errors << { message: "Order #{order_number} not found" }
+          end
+        else
+          errors << { message: 'Order number param missing' }
+        end
+
+        self
+      end
+
+      private
+
+      def upsert_card(flow_io_card, order)
+        flow_io_card_expiration = flow_io_card.delete('expiration')
+
+        card = Spree::CreditCard.find_or_initialize_by(month: flow_io_card_expiration['month'].to_s,
+                                                       year: flow_io_card_expiration['year'].to_s,
+                                                       cc_type: flow_io_card.delete('type'),
+                                                       last_digits: flow_io_card.delete('last4'),
+                                                       name: flow_io_card.delete('name'),
+                                                       user_id: order.user&.id)
+        card.flow_data ||= {}
+        if card.new_record?
+          card.flow_data.merge!(flow_io_card.except('discriminator'))
+          card.imported = true
+        end
+
+        card.push_authorization(@data.except('discriminator'))
+        card.new_record? ? card.save : card.update_column(:meta, card.meta.to_json)
+
+        card
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  module Webhooks
+    class ExperienceUpsertedV2
+      attr_accessor :errors
+      alias full_messages errors
+
+      def self.process(data, opts = {})
+        new(data, opts).process
+      end
+
+      def initialize(data, opts = {})
+        @data = data
+        @opts = opts
+        @errors = []
+      end
+
+      def process
+        experience = @data['experience']
+        Spree::Zones::Product.find_or_initialize_by(name: experience['key'].titleize).store_flow_io_data(experience)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  module Webhooks
+    class FraudStatusChanged
+      attr_accessor :errors
+      alias full_messages errors
+
+      def self.process(data, opts = {})
+        new(data, opts).process
+      end
+
+      def initialize(data, opts = {})
+        @data = data
+        @opts = opts
+        @errors = []
+      end
+
+      def process
+        order_number = @data.dig('order', 'number')
+        errors << { message: 'Order number param missing' } && (return self) unless order_number
+
+        order = Spree::Order.find_by(number: order_number)
+        errors << { message: "Order #{order_number} not found" } && (return self) unless order
+
+        if @data['status'] == 'declined'
+          order.update_columns(fraudulent: true)
+          order.cancel!
+        end
+
+        order
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  module Webhooks
+    class LocalItemUpserted
+      attr_accessor :errors
+      alias full_messages errors
+
+      def self.process(data, opts = {})
+        new(data, opts).process
+      end
+
+      def initialize(data, opts = {})
+        @data = data
+        @opts = opts
+        @errors = []
+      end
+
+      def process
+        errors << { message: 'Local item param missing' } && (return self) unless (local_item = @data['local_item'])
+
+        errors << { message: 'SKU param missing' } && (return self) unless (flow_sku = local_item.dig('item', 'number'))
+
+        if (variant = Spree::Variant.find_by(sku: flow_sku))
+          variant.add_flow_io_experience_data(
+            local_item.dig('experience', 'key'),
+            'prices' => [local_item.dig('pricing', 'price')], 'status' => local_item['status']
+          )
+
+          variant.update_column(:meta, variant.meta.to_json)
+          return variant
+        else
+          errors << { message: "Variant with sku [#{flow_sku}] not found!" }
+        end
+
+        self
+      end
+    end
+  end
+end

data/app/views/spree/admin/payments/source_views/_flow_io_gateway.html.erb

@@ -0,0 +1,21 @@
+<fieldset data-hook="credit_card">
+  <legend align="center"><%= Spree.t(:credit_card) %></legend>
+
+  <div class="row">
+    <div class="alpha six columns">
+      <dl>
+        <dt><%= Spree.t(:name_on_card) %>:</dt>
+        <dd><%= payment.source&.name %></dd>
+
+        <dt><%= Spree.t(:card_type) %>:</dt>
+        <dd><%= payment.source&.cc_type %></dd>
+
+        <dt><%= Spree.t(:card_number) %>:</dt>
+        <dd><%= payment.source&.display_number %></dd>
+
+        <dt><%= Spree.t(:expiration) %>:</dt>
+        <dd><%= payment.source&.month %>/<%= payment.source&.year %></dd>
+      </dl>
+    </div>
+  </div>
+</fieldset>

data/app/workers/flowcommerce_spree/import_item_worker.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class ImportItemWorker
+    include Sidekiq::Worker
+    sidekiq_options retry: 3, queue: :flow_io
+
+    sidekiq_retries_exhausted do |message, exception|
+      Rails.logger.warn("[!] FlowcommerceSpree::ImportItemWorker max attempts reached: #{message} - #{exception}")
+      notification_setting = FlowcommerceSpree::Config.notification_setting
+      return unless notification_setting[:slack].present?
+
+      slack_message = "[#{Rails.env}] #{message}"
+      Slack_client.chat_postMessage(channel: notification_setting[:slack][:channel], text: slack_message)
+    end
+
+    def perform(variant_sku)
+      variant = Spree::Variant.find_by sku: variant_sku
+      return unless variant
+
+      FlowcommerceSpree::ImportItem.run(variant)
+    end
+  end
+end

data/config/routes.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 FlowcommerceSpree::Engine.routes.draw do
-  post '/event-target', to: 'webhooks#handle_flow_web_hook_event'
+  post '/event-target', to: 'webhooks#handle_flow_io_event'
+  get '/order-completed', to: 'orders#order_completed'
+  post '/online-stock-availability', to: 'inventory#online_stock_availability'
 end

data/db/migrate/20201021755957_add_meta_to_spree_tables.rb

@@ -5,13 +5,15 @@ class AddMetaToSpreeTables < ActiveRecord::Migration
     add_column :spree_orders, :meta, :jsonb, default: '{}' unless column_exists?(:spree_orders, :meta)
     add_column :spree_promotions, :meta, :jsonb, default: '{}' unless column_exists?(:spree_promotions, :meta)
     add_column :spree_credit_cards, :meta, :jsonb, default: '{}' unless column_exists?(:spree_credit_cards, :meta)
+    add_column :spree_payment_capture_events, :meta, :jsonb, default: '{}' unless column_exists?(:spree_payment_capture_events, :meta)
   end
 
   def down
-    remove_column :spree_products, :meta if column_exists?(:spree_products, :meta)
-    remove_column :spree_variants, :meta if column_exists?(:spree_variants, :meta)
-    remove_column :spree_orders, :meta if column_exists?(:spree_orders, :meta)
-    remove_column :spree_promotions, :meta if column_exists?(:spree_promotions, :meta)
+    remove_column :spree_payment_capture_events, :meta if column_exists?(:spree_payment_capture_events, :meta)
     remove_column :spree_credit_cards, :meta if column_exists?(:spree_credit_cards, :meta)
+    remove_column :spree_promotions, :meta if column_exists?(:spree_promotions, :meta)
+    remove_column :spree_orders, :meta if column_exists?(:spree_orders, :meta)
+    remove_column :spree_variants, :meta if column_exists?(:spree_variants, :meta)
+    remove_column :spree_products, :meta if column_exists?(:spree_products, :meta)
   end
 end

data/lib/flow/simple_gateway.rb

@@ -34,42 +34,6 @@ module Flow
       error_response(e)
     end
 
-    # capture authorised funds
-    def cc_capture
-      # GET /:organization/authorizations, order_number: abc
-      data = @order.flow_data['authorization']
-
-      raise ArgumentError, 'No Authorization data, please authorize first' unless data
-
-      capture_form = ::Io::Flow::V0::Models::CaptureForm.new(data)
-      response = FlowcommerceSpree.client.captures.post(FlowcommerceSpree::ORGANIZATION, capture_form)
-
-      return ActiveMerchant::Billing::Response.new false, 'error', response: response unless response.id
-
-      @order.update_column :flow_data, @order.flow_data.merge('capture': response.to_hash)
-      @order.flow_finalize!
-
-      ActiveMerchant::Billing::Response.new true, 'success', response: response
-    rescue StandardError => e
-      error_response(e)
-    end
-
-    def cc_refund
-      raise ArgumentError, 'capture info is not available' unless @order.flow_data['capture']
-
-      # we allways have capture ID, so we use it
-      refund_data = { capture_id: @order.flow_data['capture']['id'] }
-      refund_form = ::Io::Flow::V0::Models::RefundForm.new(refund_data)
-      response    = FlowcommerceSpree.client.refunds.post(FlowcommerceSpree::ORGANIZATION, refund_form)
-
-      return ActiveMerchant::Billing::Response.new false, 'error', response: response unless response.id
-
-      @order.update_column :flow_data, @order.flow_data.merge('refund': response.to_hash)
-      ActiveMerchant::Billing::Response.new true, 'success', response: response
-    rescue StandardError => e
-      error_response(e)
-    end
-
     private
 
     # if order is not in flow, we use local Spree settings