flowcommerce_spree 0.0.6 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff1a7f69451b03b52d6422015450255988ac45f664a1bee62559e238e45f0a6b
-  data.tar.gz: d9fab8b6b5091b70235cde18b88dd0dc0988ed0d38946571236d9a828b0e6750
+  metadata.gz: ad7616da6a9fb5e7fbffe0a8869730ffedacb91deec3a5d08f328d2b876338ad
+  data.tar.gz: 76ffd0d23d05028ba0d24df80fa5a092efe62f0b5f14ddde339e73ede5ee53bc
 SHA512:
-  metadata.gz: 73f135866d3644fc4b9a92bc8003d88c28bdf220612e4823d2d1f04e190f3e0888f00c995e215b7efc9ebfa81bd9720b47b00e8f796bdad6b68391bb1852ec59
-  data.tar.gz: 8b2c6fe4c1d2987f4c467fb2f33afee8d0b4e15b7b6a12dddb44b28ab57c538e8c1dd9608604deca5170d70adfc011b0299ba00c7ba33c5b966a959878355a79
+  metadata.gz: 1eb2b92c39dd528cc4990d9957ee5dba29fbdfa39d7f7a4b821d07a6f5cb366541821b67a6d23ccbc9854b3c3c0867e0cd3fff8b36f64cea627b2fa6d7da47df
+  data.tar.gz: 75175908d8ff3a85ca061ea82890af39544e66bf5898409e0b38d467bc40880eb6ac8e1773263cc5e933ef54d28bf00a2fb1a3f5cddbd935793b92c7fa0e89f2

data/app/controllers/concerns/current_zone_loader_decorator.rb

@@ -31,16 +31,9 @@ CurrentZoneLoader.module_eval do
                                        .where("meta -> 'flow_data' ->> 'country' = ?",
                                               ISO3166::Country[request_iso_code]&.alpha3).exists?
 
-    request_ip = if Rails.env.production?
-                   request.ip
-                 else
-                   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)
+    flow_io_session = FlowcommerceSpree::Session.create(country: request_iso_code, visitor: visitor_id_for_flow_io)
 
     if (zone = Spree::Zones::Product.active.find_by(name: flow_io_session.experience&.key&.titleize))
       session['flow_session_id'] = flow_io_session.id

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)
@@ -86,6 +87,10 @@ module Spree
       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/session.rb

@@ -5,16 +5,14 @@ module FlowcommerceSpree
   class Session
     attr_accessor :session, :localized, :visitor
 
-    def self.create(ip:, visitor:, experience: nil)
-      instance = new(ip: ip, visitor: visitor, experience: experience)
+    def self.create(country:, visitor:, experience: nil)
+      instance = new(country: country, visitor: visitor, experience: experience)
       instance.create
       instance
     end
 
-    def initialize(ip:, visitor:, experience: nil)
-      ip = '127.0.0.1' if ip == '::1'
-
-      @ip      = ip
+    def initialize(country:, visitor:, experience: nil)
+      @country = country
       @visitor = visitor
       @experience = experience
     end
@@ -22,7 +20,7 @@ module FlowcommerceSpree
     # create session without or with experience (the latter is useful for creating a new session with the order's
     # experience on refreshing the checkout_token)
     def create
-      data = { ip: @ip,
+      data = { country: @country,
                visit: { id: @visitor,
                         expires_at: (Time.now + 30.minutes).iso8601 } }
       data[:experience] = @experience if @experience

data/lib/flowcommerce_spree/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flowcommerce_spree
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.10
 platform: ruby
 authors:
 - Aurel Branzeanu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-13 00:00:00.000000000 Z
+date: 2021-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -210,7 +210,6 @@ files:
 - app/helpers/spree/core/controller_helpers/flow_io_order_helper_decorator.rb
 - app/models/flowcommerce_spree/settings.rb
 - app/models/spree/address_decorator.rb
-- app/models/spree/app_configuration_decorator.rb
 - app/models/spree/calculator/flow_io.rb
 - app/models/spree/calculator/shipping/flow_io.rb
 - app/models/spree/flow_io_credit_card_decorator.rb
@@ -231,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
@@ -244,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
@@ -281,7 +284,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Integration of Spree with Flow API

data/app/models/spree/app_configuration_decorator.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  AppConfiguration.class_eval do
-    preference :debug_request_ip_address, :string
-  end
-end