flowcommerce_spree 0.0.7 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6aa92dd937ce7ff2ac430c684e76eaf18f80dc165191b5452407b73a51f6cc59
-  data.tar.gz: 83270c61b581abf426a1e19d65c63d6c43ea4c766ba3bf67c3fc334cb234e6f6
+  metadata.gz: d0e6c714f8986d91af70150c8365f3bde79a15b843151cc84bf5fabd83cf7e87
+  data.tar.gz: 4b0b172606e24bddd55d8254da339af2bf4751b441d918478310835102c9f282
 SHA512:
-  metadata.gz: c45520286feb21871014953ccaa0dd8d18d27520db9b31f05ef062f2e45d3d9b7b4de98807f46d3b4e0ec6acf63ed98e472fe0d37d4290f1b9bcd36ec21363db
-  data.tar.gz: 37f630c22db5e978c4325ee6a5029cfe5c45940d817b537fd80f3bb750e63fd50d235796d078b0a6ac028136ab3075703b78030edd3a392c35f87e8bd2327740
+  metadata.gz: 915818b7f7ffd75a3e2adf67d25403b5ea342b0095f2b051d4044ef91c942bee15e2e6b0a235a62f53b7e95af88f6b2626f0a3a58767214e413ad9fc3695a36a
+  data.tar.gz: '048827e500e921d90c3dba7169644a09702f89551be7083820b0d4c337a97a0f513609417dee1f9017f266a8f28bf846dcb5c124262dee7fed03defecbda97fd'

data/app/models/flowcommerce_spree/settings.rb

@@ -4,5 +4,6 @@ module FlowcommerceSpree
   class Settings < Spree::Preferences::Configuration
     preference :additional_attributes, :hash, default: {}
     preference :product_catalog_upload, :hash, default: {}
+    preference :notification_setting, :hash, default: {}
   end
 end

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

@@ -11,8 +11,8 @@ module Spree
         order = item.order
 
         if can_calculate_tax?(order)
-          flow_response = get_flow_tax_data(order)
-          tax_for_item(item, flow_response)
+          get_flow_tax_data(order)
+          tax_for_item(item)
         else
           prev_tax_amount(item)
         end
@@ -20,6 +20,13 @@ module Spree
       alias compute_shipment compute_shipment_or_line_item
       alias compute_line_item compute_shipment_or_line_item
 
+      def get_tax_rate(taxable)
+        order = taxable.class.to_s == 'Spree::Order' ? taxable : taxable.order
+        get_flow_tax_data(order) if order.flow_allocations.empty?
+        response = order.flow_tax_for_item(taxable.adjustable, 'vat_item_price', rate.included_in_price)
+        response.nil? ? 0 : response['rate']&.to_f
+      end
+
       private
 
       def prev_tax_amount(item)
@@ -39,21 +46,26 @@ module Spree
 
       def get_flow_tax_data(order)
         flow_io_tax_response = Rails.cache.fetch(order.flow_tax_cache_key, time_to_idle: 5.minutes) do
-          FlowcommerceSpree.client.orders.get_allocations_by_number(FlowcommerceSpree::ORGANIZATION, order.number)
+          response = FlowcommerceSpree.client.orders
+                                      .get_allocations_by_number(FlowcommerceSpree::ORGANIZATION, order.number)
+          return nil unless response.present?
+
+          order.flow_order['allocations'] = response.to_hash
+          order.update_column(:meta, order.meta.to_json)
+          response
         end
         flow_io_tax_response
       end
 
-      def tax_for_item(item, flow_response)
+      def tax_for_item(item)
+        order = item.order
         prev_tax_amount = prev_tax_amount(item)
-        return prev_tax_amount if flow_response.nil?
-
-        item_details = flow_response.details&.find do |el|
-          item.is_a?(Spree::LineItem) ? el.number == item.variant.sku : el.key.value == 'shipping'
-        end
-        price_components = rate.included_in_price ? item_details.included : item_details.not_included
+        tax_data = order.flow_tax_for_item(item, 'vat_item_price', rate.included_in_price)
+        return prev_tax_amount if tax_data.blank?
 
-        amount = price_components&.find { |el| el.key.value == 'vat_item_price' }&.total&.amount
+        subsidy_data = order.flow_tax_for_item(item, 'vat_subsidy', rate.included_in_price)
+        amount = tax_data.dig('total', 'amount')
+        amount += subsidy_data.dig('total', 'amount') if subsidy_data.present?
         amount.present? && amount > 0 ? amount : prev_tax_amount
       end
     end

data/app/models/spree/flow_io_order_decorator.rb

@@ -158,6 +158,24 @@ module Spree
       address_attributes
     end
 
+    def flow_allocations
+      return @flow_allocations if @flow_allocations
+
+      @flow_allocations = flow_order&.[]('allocations')
+    end
+
+    def flow_tax_for_item(item, tax_key, included_in_price = true)
+      return {} if flow_allocations.blank?
+
+      item_details = flow_allocations['details']&.find do |el|
+        item.is_a?(Spree::LineItem) ? el['number'] == item.variant.sku : el['key'] == 'shipping'
+      end
+      return {} if item_details.blank?
+
+      price_components = included_in_price ? item_details['included'] : item_details['not_included']
+      price_components&.find { |el| el['key'] == tax_key }
+    end
+
     Spree::Order.include(self) if Spree::Order.included_modules.exclude?(self)
   end
 end

data/app/models/spree/flow_io_product_decorator.rb

@@ -7,6 +7,7 @@ module Spree
       base.serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
 
       base.store_accessor :meta, :flow_data, :zone_ids
+      base.after_save :sync_variants_with_flow
     end
 
     def price_in_zone(currency, product_zone)
@@ -27,9 +28,9 @@ module Spree
       flow_data["#{flow_exp.key}.excluded"].to_i != 1
     end
 
-    def price_range(product_zone)
+    def price_range(product_zone, currencies = [])
       prices = {}
-      master_prices.each do |p|
+      master_prices_with_currencies(currencies).each do |p|
         currency = p.currency
         min = nil
         max = nil
@@ -39,15 +40,15 @@ module Spree
             price = v.price_in(currency)
             next if price.nil? || price.amount.nil?
 
-            min = price if min.nil? || min.amount > price.amount
-            max = price if max.nil? || max.amount < price.amount
+            min = [price, min].compact.min { |a, b| a.amount <=> b.amount }
+            max = [price, max].compact.max { |a, b| a.amount <=> b.amount }
           end
         else
           min = max = master.price_in(currency)
         end
 
-        rmin = min&.amount&.to_s(:rounded, precision: 0) || 0
-        rmax = max&.amount&.to_s(:rounded, precision: 0) || 0
+        rmin = round_with_precision(min, 0)
+        rmax = round_with_precision(max, 0)
 
         prices[currency] = { min: rmin, max: rmax }
       end
@@ -55,6 +56,10 @@ module Spree
       add_flow_price_range(prices, product_zone)
     end
 
+    def round_with_precision(number, precision)
+      number&.amount&.to_s(:rounded, precision: precision) || 0
+    end
+
     def add_flow_price_range(prices, product_zone)
       flow_experience_key = product_zone&.flow_data&.[]('key')
       return prices if flow_experience_key.blank?
@@ -69,8 +74,8 @@ module Spree
           price = v.flow_local_price(flow_experience_key)
           next if price.amount.nil? || price.currency != currency
 
-          min = price if min.nil? || min.amount > price.amount
-          max = price if max.nil? || max.amount < price.amount
+          min = [price, min].compact.min { |a, b| a.amount <=> b.amount }
+          max = [price, max].compact.max { |a, b| a.amount <=> b.amount }
         end
       end
 
@@ -79,13 +84,17 @@ module Spree
         max ||= master_price
       end
 
-      rmin = min&.amount&.to_s(:rounded, precision: 0) || 0
-      rmax = max&.amount&.to_s(:rounded, precision: 0) || 0
+      rmin = round_with_precision(min, 0)
+      rmax = round_with_precision(max, 0)
 
       prices[currency] = { min: rmin, max: rmax }
       prices
     end
 
+    def sync_variants_with_flow
+      variants_including_master.each(&:sync_product_to_flow)
+    end
+
     Spree::Product.prepend(self) if Spree::Product.included_modules.exclude?(self)
   end
 end

data/app/models/spree/flow_io_variant_decorator.rb

@@ -49,17 +49,23 @@ module Spree
       product.update_columns(meta: product.meta.to_json)
     end
 
+    def sync_flow_info?
+      if FlowcommerceSpree::API_KEY.blank? || FlowcommerceSpree::API_KEY == 'test_key'
+        return { error: 'Api Keys not configured' }
+      end
+      return { error: 'Price is 0' } if price == 0
+      return { error: 'Country of Origin is empty.' } unless country_of_origin
+    end
+
     # upload product variant to Flow's Product Catalog
     def sync_product_to_flow
-      # initial Spree seed will fail, so skip unless we have Flow data field
-      return unless respond_to?(:flow_data)
-
-      return if FlowcommerceSpree::API_KEY.blank? || FlowcommerceSpree::API_KEY == 'test_key'
+      error = sync_flow_info?
+      return error if error.present?
 
-      return { error: 'Price is 0' } if price == 0
-
-      return unless country_of_origin
+      update_flow_data
+    end
 
+    def update_flow_data
       additional_attrs = {}
       attr_name = nil
       export_required = false
@@ -84,7 +90,7 @@ module Spree
       flow_item_sh1 = Digest::SHA1.hexdigest(flow_item.to_json)
 
       # skip if sync not needed
-      return nil if flow_data&.[](:last_sync_sh1) == flow_item_sh1
+      return { error: 'Synchronization not needed' } if flow_data&.[](:last_sync_sh1) == flow_item_sh1
 
       response = FlowcommerceSpree.client.items.put_by_number(FlowcommerceSpree::ORGANIZATION, sku, flow_item)
       self.flow_data ||= {}
@@ -93,6 +99,8 @@ module Spree
       # after successful put, write cache
       update_column(:meta, meta.to_json)
 
+      FlowcommerceSpree::ImportItemWorker.perform_async(sku)
+
       response
     rescue Net::OpenTimeout => e
       { error: e.message }

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/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

@@ -124,7 +124,7 @@ 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
 

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

@@ -22,16 +22,25 @@ module FlowcommerceSpree
         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
+          if order.payments.any?
+            store_payment_capture(order, capture)
+          else
+            FlowcommerceSpree::UpdatePaymentCaptureWorker.perform_in(1.minute, order.number, capture)
+            order
+          end
         else
           errors << { message: "Order #{order_number} not found" }
           self
         end
       end
 
+      def store_payment_capture(order, capture)
+        upsert_order_captures(order, capture)
+        payments = order.flow_io_payments
+        map_payment_captures_to_spree(order, payments) if payments.present?
+        order
+      end
+
       private
 
       def upsert_order_captures(order, capture)

data/app/workers/flowcommerce_spree/flow_io_worker.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class FlowIoWorker
+    include Sidekiq::Worker
+
+    sidekiq_retries_exhausted do |message, exception|
+      Rails.logger.warn("[!] #{self.class} 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
+  end
+end

data/app/workers/flowcommerce_spree/import_item_worker.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class ImportItemWorker < FlowIoWorker
+    sidekiq_options retry: 3, queue: :flow_io
+
+    def perform(variant_sku)
+      variant = Spree::Variant.find_by sku: variant_sku
+      return unless variant
+
+      FlowcommerceSpree::ImportItem.run(variant)
+    end
+  end
+end

data/app/workers/flowcommerce_spree/update_payment_capture_worker.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class UpdatePaymentCaptureWorker < FlowIoWorker
+    sidekiq_options retry: 3, queue: :flow_io
+
+    def perform(order_number, capture = {})
+      order = Spree::Order.find_by number: order_number
+      raise 'Order has no payments' if order.payments.empty?
+
+      FlowcommerceSpree::Webhooks::CaptureUpsertedV2.new({ capture: capture }.as_json)
+                                                    .store_payment_capture(order, capture)
+    end
+  end
+end

data/lib/flowcommerce_spree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FlowcommerceSpree
-  VERSION = '0.0.7'
+  VERSION = '0.0.11'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flowcommerce_spree
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.11
 platform: ruby
 authors:
 - Aurel Branzeanu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-16 00:00:00.000000000 Z
+date: 2021-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -230,6 +230,7 @@ files:
 - app/serializers/api/v2/order_serializer_decorator.rb
 - app/services/flowcommerce_spree/import_experience_items.rb
 - app/services/flowcommerce_spree/import_experiences.rb
+- app/services/flowcommerce_spree/import_item.rb
 - app/services/flowcommerce_spree/order_sync.rb
 - app/services/flowcommerce_spree/order_updater.rb
 - app/services/flowcommerce_spree/webhooks/capture_upserted_v2.rb
@@ -243,6 +244,9 @@ files:
 - app/views/spree/admin/promotions/edit.html.erb
 - app/views/spree/admin/shared/_order_summary.html.erb
 - app/views/spree/admin/shared/_order_summary_flow.html.erb
+- app/workers/flowcommerce_spree/flow_io_worker.rb
+- app/workers/flowcommerce_spree/import_item_worker.rb
+- app/workers/flowcommerce_spree/update_payment_capture_worker.rb
 - config/rails_best_practices.yml
 - config/routes.rb
 - db/migrate/20201021160159_add_type_and_meta_to_spree_zone.rb