flowcommerce_spree 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 679a3d268ba2e06caff2460bcfd86b671630de034567017f5a9b8f51a6c20d4b
-  data.tar.gz: 6c95ee74d3783dbb01f1aa1ae9107b386b75de5de9f298d9ea65270ed5a43ffa
+  metadata.gz: 51a668ee3cc70d0bc9bd8c7662a972f086e06dcdcf4c68df2177e94818dfb820
+  data.tar.gz: aa9ff17e57cd19452736af11d51bd1905c4dd7e66bb461b5dff017fc5dea0b0d
 SHA512:
-  metadata.gz: af6dba3c9673dbedf2b3d3672c9dc7a09375a7bc12581393ec4173df0cefe2157d2d4022bcf3b0ac0ceeedf87b91fd6e71558d296d1d848d60abac18de9de47a
-  data.tar.gz: 9ad313a9ab18cb88bb9fe68dff643933bf2b940613ca1a11fd5014c51cfa26bf911443074254c719d393cb1671ef36819b3e292730d677622135bf94a464c83e
+  metadata.gz: 024a29a6fc47f932e432f2477f9a1f3b520af7cc10b7a85eb35613328276d5390a682187151217c0527b20435431f78e8cc55255d95298620bfb5077c7ed5011
+  data.tar.gz: b6d9485612e360ed50caabfab537baf9583feec384607b4a890c1ab1fd9fc48cd9ea3954562aac828f4a858682ad1515ae7f2b9bf05a8a501ff8abf96c28f972

data/README.md

@@ -11,32 +11,36 @@ All flowcommerce_spree code is located in the ./app and ./lib folders.
     gem 'flowcommerce_spree', git: 'https://github.com/mejuri-inc/flowcommerce_spree'
     ```
 
-- If the main application's Rails version is less than 4.2, add also  to main application's Gemfile the `activerecord
--postgres-json` gem (the mejuri-inc fork allows using a recent Rake version:
+- If the main application's Rails version is less than 4.2, add also to main application's Gemfile the `activerecord
+-postgres-json` gem (at least version 0.2.3):
 
     ```
-    gem 'activerecord-postgres-json', git: 'https://github.com/mejuri-inc/activerecord-postgres-json'
+    gem 'activerecord-postgres-json', '>= 0.2.3'
     ```
- 
 
 - Run `bundle install`.
 
-- Define this additional ENV variables. You will find them in 
+- Define this additional ENV variables. You will find all of them, except FLOW_MOUNT_PATH in 
   [Flow console](https://console.flow.io/org_account_name/organization/integrations):
 
     ```
     FLOW_TOKEN='SUPERsecretTOKEN' # API_KEY
     FLOW_ORGANIZATION='spree-app-sandbox'
     FLOW_BASE_COUNTRY='usa'
+    # The path to which the FlowcommerceSpree engine will be mounted (default, if this variable is missing, will be the 
+    # '/flow' path)
+    FLOW_MOUNT_PATH='/flow' 
     ```
 
-- The only piece of code that is needed to enable payments with the FlowCommerce engine
+- To enable payments with the FlowCommerce engine, the payment method `flow.io` with `Spree::Gateway::FlowIo` should be 
+  added in the Spree Admin. This payment method is automatically registered in the gem in an after_initialize Rails 
+  engine callback:
 
     ```
-      # config/application.rb
+      # lib/flowcommerce_spree/engine.rb
       config.after_initialize do |app|
         # init Flow payments as an option
-        app.config.spree.payment_methods << Spree::Gateway::Flow
+        app.config.spree.payment_methods << Spree::Gateway::FlowIo
       end
     ```
 
@@ -80,7 +84,7 @@ Decorators are used extensively across the gem to modify or add behaviour of sev
 properly deal with the precedence in the Ruby ancestor chain, the `class_eval`, `include` and `prepend` methods are 
 being used, depending on the level of modification.
 
-### Spree::Flow::Gateway
+### Spree::Gateway::FlowIo
 
 Adapter for Spree, that allows using [Flow.io](https://www.flow.io) as payment gateway. Flow is PCI compliant payment processor.
 

data/SPREE_FLOW.md

@@ -2,40 +2,19 @@
 
 Integration of Spree with Flow, how it is done.
 
-I plan to be concise as possible, but cover all important topics.
+## Installation
 
-## Instalation
-
-Add the following lines to `./config/application.rb` :
-
-```
-  config.to_prepare do
-    # add all flow libs
-    overload = Dir.glob('./app/flow/**/*.rb')
-    overload.reverse.each { |c| require(c) }
-  end
-
-  config.after_initialize do |app|
-    # init Flow payments as an option
-    app.config.spree.payment_methods << Spree::Gateway::Flow
-  end
-```
-
-Additional configuration could be adjusted in the gem's initializer. For example, the following file could be created in the main application:
+Additional configuration could be adjusted in the gem's initializer. For example, the following file could be created 
+in the main application, which would add additional attributes of spree_variants to be imported/exported to flow.io:
 
 ```
 # ./config/initializers/flowcommerce_spree.rb
 
-FlowcommerceSpree.configure do |c|
-  c.experience_associator = FlowcommerceSpree::ExperienceAssociator
-end
+FlowcommerceSpree::Config.additional_attributes =
+  { spree_variants: { country_of_origin: { import: true, export: :optional },
+                      customs_description: { import: true, export: :optional, export_name: 'materials' } } }
 ```
 
-### Configurable settings
-
-1. experience_associator - this attribute could be assigned, if necessary, a service object to perform some
- additional association actions when upserting a FlowcommerceSpree::Experience model
-
 ## Things to take into account
 
 ActiveMerchant is not supporting sessions and orders, natively. If one wants
@@ -131,4 +110,3 @@ By default Flow Admin (on /admin/flow) is anybody that is Spree admin.
 
 This way we provide good frontend info, some integration notes in realtime as opposed to running
 rake tests to check for integrity of Flow integration.
-

data/app/controllers/concerns/current_zone_loader_decorator.rb

@@ -3,29 +3,52 @@
 CurrentZoneLoader.module_eval do
   extend ActiveSupport::Concern
 
-  def flow_zone # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+  def current_zone
+    return @current_zone if defined?(@current_zone)
+
+    @current_zone = if (session_region_name = session['region']&.[]('name'))
+                      Spree::Zones::Product.find_by(name: session_region_name)
+                    elsif request_iso_code.present?
+                      @current_zone = flow_zone
+                      @current_zone ||= Spree::Country.find_by(iso: request_iso_code)&.product_zones&.active&.first
+                    end
+
+    @current_zone ||= Spree::Zones::Product.find_by(name: 'International') ||
+                      Spree::Zones::Product.new(name: 'International', taxon_ids: [], currencies: %w[USD CAD])
+
+    current_zone_name = @current_zone.name
+    session['region'] = { name: current_zone_name, available_currencies: @current_zone.available_currencies,
+                          request_iso_code: request_iso_code }
+
+    RequestStore.store[:session] = session
+    Rails.logger.debug("Using product zone: #{current_zone_name}")
+    @current_zone
+  end
+
+  def flow_zone # rubocop:disable Metrics/AbcSize
     return unless Spree::Zones::Product.active
                                        .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
-    flow_io_session = FlowcommerceSpree::Session
-                      .new(ip: request_ip, visitor: visitor_id_for_flow_io)
+    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
+    flow_io_session = FlowcommerceSpree::Session.create(ip: request_ip, visitor: visitor_id_for_flow_io)
     # :create method will issue a request to flow.io. The experience, contained in the
     # response, will be available in the session object - flow_io_session.experience
-    flow_io_session.create
-    zone = Spree::Zones::Product.active.find_by(name: flow_io_session.experience&.key&.titleize)
-    session['_f60_session'] = flow_io_session.id if zone
+
+    if (zone = Spree::Zones::Product.active.find_by(name: flow_io_session.experience&.key&.titleize))
+      session['_f60_session'] = flow_io_session.id
+      session['_f60_expires_at'] = flow_io_session.expires_at.to_s
+    end
+
     zone
   end
 
-  # composes an unique vistor id for FlowcommerceSpree::Session model
+  # composes an unique visitor id for FlowcommerceSpree::Session model
   def visitor_id_for_flow_io
     guest_token = cookies.signed[:guest_token]
     uid = if guest_token
@@ -37,13 +60,4 @@ CurrentZoneLoader.module_eval do
 
     "session-#{uid}"
   end
-
-  def fetch_product_for_zone(product)
-    Rails.cache.fetch(
-      "product_zone_#{current_zone.name}_#{product.sku}", expires_in: 1.day,
-                                                          race_condition_ttl: 10.seconds, compress: true
-    ) do
-      Spree::Zones::Product.find_product_for_zone(product, current_zone)
-    end
-  end
 end

data/app/controllers/flowcommerce_spree/webhooks_controller.rb

@@ -2,14 +2,17 @@
 
 module FlowcommerceSpree
   class WebhooksController < ActionController::Base
+    wrap_parameters false
     respond_to :json
 
     # forward all incoming requests to Flow WebhookService object
     # /flow/event-target endpoint
     def handle_flow_web_hook_event
-      webhook_result = WebhookService.process(params[:webhook])
-      result = {}
-      result[:error] = webhook_result.full_messages.join("\n") if webhook_result.errors.any?
+      result = check_organization
+      if result.blank?
+        webhook_result = WebhookService.process(params)
+        result[:error] = webhook_result.full_messages.join("\n") if webhook_result.errors.any?
+      end
     rescue StandardError => e
       result = { error: e.class.to_s, message: e.message, backtrace: e.backtrace }
     ensure
@@ -21,5 +24,14 @@ module FlowcommerceSpree
                         end
       render json: result.except(:backtrace), status: response_status
     end
+
+    private
+
+    def check_organization
+      org = params[:organization]
+      return {} if org == FlowcommerceSpree::ORGANIZATION
+
+      { error: 'InvalidParam', message: "Organization '#{org}' is invalid!" }
+    end
   end
 end

data/app/controllers/users/sessions_controller_decorator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Users
+  SessionsController.class_eval do
+    private
+
+    def external_checkout?
+      current_zone.flow_io_active_experience? ? 'true' : 'false'
+    end
+  end
+end

data/app/helpers/spree/core/controller_helpers/flow_io_order_helper_decorator.rb

@@ -12,16 +12,27 @@ module Spree
           update_meta = @current_order.zone_id ? nil : true
           @current_order.zone = current_zone
 
-          if @current_order.zone&.flow_io_active_experience? && @current_order.flow_io_experience_key.nil?
-            @current_order.flow_io_experience_from_zone
-            order_flow_io_session_id = @current_order.flow_data['session_id']
+          if @current_order.zone&.flow_io_active_experience?
+            if @current_order.flow_io_experience_key.nil?
+              @current_order.flow_io_experience_from_zone
+              update_meta ||= true
+            end
+            order_flow_session_id = @current_order.flow_data['session_id']
+            order_session_expired = @current_order.flow_data['session_expires_at']
             flow_io_session_id = session['_f60_session']
-            if order_flow_io_session_id.present? && flow_io_session_id.blank?
-              session['_f60_session'] = order_flow_io_session_id
-            elsif flow_io_session_id.present?
-              @current_order.flow_data['session_id'] = flow_io_session_id
+            flow_io_session_expires = session['_f60_expires_at']
+            if flow_io_session_id.present?
+              if order_flow_session_id != flow_io_session_id &&
+                 order_session_expired&.to_datetime.to_i < flow_io_session_expires&.to_datetime.to_i
+                @current_order.flow_data['session_id'] = flow_io_session_id
+                @current_order.flow_data['session_expires_at'] = flow_io_session_expires
+                @current_order.flow_data['checkout_token'] = nil
+                update_meta ||= true
+              end
+            elsif order_flow_session_id.present?
+              session['_f60_session'] = order_flow_session_id
+              session['_f60_expires_at'] = order_session_expired
             end
-            update_meta = true
           end
 
           if @current_order.new_record?

data/app/models/spree/address_decorator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Spree
+  Address.class_eval do
+    def prepare_from_flow_attributes(address_data)
+      self.attributes = {
+        first_name: address_data['first'],
+        last_name: address_data['last'],
+        phone: address_data['phone'],
+        address1: address_data['streets'][0],
+        address2: address_data['streets'][1],
+        zipcode: address_data['postal'],
+        city: address_data['city'],
+        state_name: address_data['province'] || 'something',
+        country: Spree::Country.find_by(iso3: address_data['country'])
+      }
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Spree
+  class Calculator
+    class FlowIo < Calculator::DefaultTax
+      def self.description
+        'FlowIO Calculator'
+      end
+
+      def compute_shipment_or_line_item(item)
+        order = item.order
+
+        if can_calculate_tax?(order)
+          flow_response = get_flow_tax_data(order)
+          tax_for_item(item, flow_response)
+        else
+          prev_tax_amount(item)
+        end
+      end
+      alias compute_shipment compute_shipment_or_line_item
+      alias compute_line_item compute_shipment_or_line_item
+
+      private
+
+      def prev_tax_amount(item)
+        if rate.included_in_price
+          item.included_tax_total
+        else
+          item.additional_tax_total
+        end
+      end
+
+      def can_calculate_tax?(order)
+        return false if order.flow_data.blank?
+        return false if %w[cart address delivery].include?(order.state)
+
+        true
+      end
+
+      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)
+        end
+        flow_io_tax_response
+      end
+
+      def tax_for_item(item, flow_response)
+        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
+
+        amount = price_components&.find { |el| el.key.value == 'vat_item_price' }&.total&.amount
+        amount.present? && amount > 0 ? amount : prev_tax_amount
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Spree
+  class Calculator
+    module Shipping
+      class FlowIo < ShippingCalculator
+        def self.description
+          'FlowIO Calculator'
+        end
+
+        def compute_package(package)
+          flow_order = flow_order(package)
+          return unless flow_order
+
+          flow_order['prices'].find { |x| x['key'] == 'shipping' }['amount'] || 0
+        end
+
+        def default_charge(_country)
+          0
+        end
+
+        def threshold
+          0
+        end
+
+        private
+
+        def flow_order(package)
+          return @flow_order if defined?(@flow_order)
+
+          @flow_order = package.order.flow_data&.[]('order')
+          @flow_order
+        end
+      end
+    end
+  end
+end

data/app/models/spree/flow_io_variant_decorator.rb

@@ -22,8 +22,8 @@ module Spree
       raise ArgumentError, 'Value should be a hash' unless value.is_a?(Hash)
 
       self.flow_data = flow_data || {}
-      self.flow_data['exp'] ||= {}
-      self.flow_data['exp'][exp] = value
+      self.flow_data['exp'] ||= {} # rubocop:disable Style/RedundantSelf
+      self.flow_data['exp'][exp] = value # rubocop:disable Style/RedundantSelf
     end
 
     # clears flow_data from the records

data/app/models/spree/gateway/{spree_flow_gateway.rb → flow_io.rb}

@@ -4,7 +4,7 @@
 # adapter for Spree that talks to activemerchant_flow
 module Spree
   class Gateway
-    class Flow < Gateway
+    class FlowIo < Gateway
       def provider_class
         self.class
       end
@@ -81,7 +81,7 @@ module Spree
       def profile_ensure_payment_method_is_present!
         return if @credit_card.payment_method_id
 
-        flow_payment = Spree::PaymentMethod.where(active: true, type: 'Spree::Gateway::Flow').first
+        flow_payment = Spree::PaymentMethod.where(active: true, type: 'Spree::Gateway::FlowIo').first
         @credit_card.payment_method_id = flow_payment.id if flow_payment
       end
 

data/app/models/spree/order_decorator.rb

@@ -11,6 +11,10 @@ module Spree # rubocop:disable Metrics/ModuleLength
     before_save :sync_to_flow_io
     after_touch :sync_to_flow_io
 
+    def flow_tax_cache_key
+      [number, 'flowcommerce', 'allocation', line_items.sum(:quantity)].join('-')
+    end
+
     def sync_to_flow_io
       return unless zone&.flow_io_active_experience? && state == 'cart' && line_items.size > 0
 
@@ -34,10 +38,7 @@ module Spree # rubocop:disable Metrics/ModuleLength
     # accepts line item, usually called from views
     def flow_line_item_price(line_item, total = false)
       result = if flow_order
-                 id = line_item.variant.sku
-
-                 lines = flow_order.lines || []
-                 item  = lines.find { |el| el['item_number'] == id }
+                 item = flow_order.lines&.find { |el| el['item_number'] == line_item.variant.sku }
 
                  return 'n/a' unless item
 
@@ -107,6 +108,10 @@ module Spree # rubocop:disable Metrics/ModuleLength
       model.new ENV.fetch('FLOW_BASE_COUNTRY')
     end
 
+    def flow_io_checkout_token
+      flow_data&.[]('checkout_token')
+    end
+
     def flow_io_experience_key
       flow_data&.[]('exp')
     end
@@ -119,29 +124,40 @@ module Spree # rubocop:disable Metrics/ModuleLength
       flow_data&.dig('order', 'id')
     end
 
+    def flow_io_session_expires_at
+      flow_data&.[]('session_expires_at')&.to_datetime
+    end
+
     def flow_io_attributes
       flow_data&.dig('order', 'attributes') || {}
     end
 
-    def add_user_consent_to_flow_data(consent, value)
+    def add_flow_checkout_token(token)
+      self.flow_data ||= {}
+      self.flow_data['checkout_token'] = token
+    end
+
+    def flow_io_attribute_add(attr_key, value)
       self.flow_data['order'] ||= {}
       self.flow_data['order']['attributes'] ||= {}
-      self.flow_data['order']['attributes'][consent] = value
+      self.flow_data['order']['attributes'][attr_key] = value
     end
 
     def add_user_uuid_to_flow_data
       self.flow_data['order'] ||= {}
       self.flow_data['order']['attributes'] ||= {}
-      self.flow_data['order']['attributes']['user_uuid'] = user&.uuid
+      self.flow_data['order']['attributes']['user_uuid'] = user&.uuid || ''
     end
 
-    def flow_io_user_uuid
+    def flow_io_attr_user_uuid
       flow_data&.dig('order', 'attributes', 'user_uuid')
     end
 
     def checkout_url
-      "https://checkout.flow.io/#{FlowcommerceSpree::ORGANIZATION}/checkout/#{number}/" \
-        "contact-info?flow_session_id=#{flow_data['session_id']}"
+      FlowcommerceSpree::OrderSync.new(order: self).synchronize!
+
+      checkout_token = flow_io_checkout_token
+      return "https://checkout.flow.io/tokens/#{checkout_token}" if checkout_token
     end
 
     # clear invalid zero amount payments. Solidus bug?
@@ -175,5 +191,54 @@ module Spree # rubocop:disable Metrics/ModuleLength
         'cc' # creait card is default
       end
     end
+
+    def flow_customer_email
+      flow_data.dig('order', 'customer', 'email')
+    end
+
+    def flow_ship_address
+      flow_destination = flow_data.dig('order', 'destination')
+      return unless flow_destination.present?
+
+      flow_destination['first'] = flow_destination.dig('contact', 'name', 'first')
+      flow_destination['last']  = flow_destination.dig('contact', 'name', 'last')
+      flow_destination['phone'] = flow_destination.dig('contact', 'phone')
+
+      s_address = ship_address || build_ship_address
+      s_address.prepare_from_flow_attributes(flow_destination)
+      s_address
+    end
+
+    def flow_bill_address
+      flow_payment_address = flow_data.dig('order', 'payments')&.last&.[]('address')
+      return unless flow_payment_address
+
+      flow_payment_address['first'] = flow_payment_address.dig('name', 'first')
+      flow_payment_address['last']  = flow_payment_address.dig('name', 'last')
+      flow_payment_address['phone'] = ship_address['phone']
+
+      b_address = bill_address || build_bill_address
+      b_address.prepare_from_flow_attributes(flow_payment_address)
+      b_address
+    end
+
+    def prepare_flow_addresses
+      address_attributes = {}
+
+      s_address = flow_ship_address
+
+      if s_address&.changes&.any?
+        s_address.save
+        address_attributes[:ship_address_id] = s_address.id unless ship_address_id
+      end
+
+      b_address = flow_bill_address
+      if b_address&.changes&.any?
+        b_address.save
+        address_attributes[:bill_address_id] = b_address.id unless bill_address_id
+      end
+
+      address_attributes
+    end
   end
 end