flowcommerce_spree 0.0.2 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 679a3d268ba2e06caff2460bcfd86b671630de034567017f5a9b8f51a6c20d4b
-  data.tar.gz: 6c95ee74d3783dbb01f1aa1ae9107b386b75de5de9f298d9ea65270ed5a43ffa
+  metadata.gz: 6aa92dd937ce7ff2ac430c684e76eaf18f80dc165191b5452407b73a51f6cc59
+  data.tar.gz: 83270c61b581abf426a1e19d65c63d6c43ea4c766ba3bf67c3fc334cb234e6f6
 SHA512:
-  metadata.gz: af6dba3c9673dbedf2b3d3672c9dc7a09375a7bc12581393ec4173df0cefe2157d2d4022bcf3b0ac0ceeedf87b91fd6e71558d296d1d848d60abac18de9de47a
-  data.tar.gz: 9ad313a9ab18cb88bb9fe68dff643933bf2b940613ca1a11fd5014c51cfa26bf911443074254c719d393cb1671ef36819b3e292730d677622135bf94a464c83e
+  metadata.gz: c45520286feb21871014953ccaa0dd8d18d27520db9b31f05ef062f2e45d3d9b7b4de98807f46d3b4e0ec6acf63ed98e472fe0d37d4290f1b9bcd36ec21363db
+  data.tar.gz: 37f630c22db5e978c4325ee6a5029cfe5c45940d817b537fd80f3bb750e63fd50d235796d078b0a6ac028136ab3075703b78030edd3a392c35f87e8bd2327740

data/README.md

@@ -11,32 +11,46 @@ 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 
-  [Flow console](https://console.flow.io/org_account_name/organization/integrations):
+- Define these additional ENV variables. 
+  - You will find FLOW_TOKEN, FLOW_ORGANIZATION and FLOW_BASE_COUNTRY in [Flow 
+  console](https://console.flow.io/org_account_name/organization/integrations)
+  - To enable HTTP Basic authentication for securing the FlowcommerceSpree::WebhooksController, prepend 
+    username:password@ to the hostname in your webhook URL. 
+    By doing so, the credentials needed for authentication will be sent in the HTTP header.
+    For example: https://username:password@www.mywebhookurl.com
+    On the main app's backend side, the `username` and `password` values should be defined in the 
+    FLOW_IO_WEBHOOK_USER and FLOW_IO_WEBHOOK_PASSWORD environment variables
 
     ```
     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 following variables should be set for securing the FlowcommerceSpree::WebhooksControler
+    FLOW_IO_WEBHOOK_USER
+    FLOW_IO_WEBHOOK_PASSWORD
     ```
 
-- 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,9 +94,11 @@ 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.
 
-Adapter for Spree, that allows using [Flow.io](https://www.flow.io) as payment gateway. Flow is PCI compliant payment processor.
 
 ## Gem Maintenance
 
@@ -125,11 +141,28 @@ by the following command:
 gem build flowcommerce_spree.gemspec
 ```
 
-Asuming the version was set to `0.0.1`, a `flowcommerce_spree-0.0.1.gem` will be generated at the root of the app 
-(repo).
+Assuming the version was set to `0.0.1`, 
+a `flowcommerce_spree-0.0.1.gem` binary file will be generated at the root of the app (repo).
+
+- The binary file shouldn't be added into the `git` tree, it will be pushed into the RubyGems and to the GitHub releases
 
 ### Pushing a new gem release to RubyGems
 
 ```
 gem push flowcommerce_spree-0.0.1.gem # don't forget to specify the correct version number
 ```
+
+### Crafting the new release on GitHub
+
+On the [Releases page](https://github.com/mejuri-inc/flowcommerce_spree/releases) push the `Draft a new release` button.
+
+The new release editing page opens, on which the following actions could be taken:
+
+- Choose the repo branch (default is `main`)
+- Insert a tag version (usually, the tag should correspond to the gem's new version, v0.0.1, for example)
+    - the tag will be created by GitHub on the last commit into the chosen branch
+- Fill the release Title and Description
+- Attach the binary file with the generated gem version
+- If the release is not yet ready for production, mark the `This is a pre-release` checkbox
+- Press either the `Publish release`, or the `Save draft button` if you want to publish it later
+    - After publishing the release, the the binary gem file will be available on GitHub and could be removed locally

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,46 @@
 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, status: 'active')
+                    end
+
+    @current_zone ||= if 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 }
+
+    Rails.logger.debug("Using product zone: #{current_zone_name}")
+    @current_zone
+  end
+
+  def flow_zone
     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)
-    # :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
+    # 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(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
+    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 +54,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/inventory_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class InventoryController < ActionController::Base
+    def online_stock_availability
+      items = params['items'] || []
+      response = items.inject([]) { |result, item| result << check_stock(item[:id], item[:qty].to_i) }
+      render json: { items: response }, status: :ok
+    end
+
+    private
+
+    def check_stock(flow_number, quantity)
+      variant = Spree::Variant.find_by(sku: flow_number)
+      return { id: flow_number, has_inventory: false } unless variant
+
+      { id: flow_number, has_inventory: variant.available_online?(quantity) }
+    rescue StandardError
+      Rails.logger.error "[!] FlowcommerceSpree::InventoryController#stock unexpected Error: #{$ERROR_INFO}"
+      { id: flow_number, has_inventory: false }
+    end
+  end
+end

data/app/controllers/flowcommerce_spree/orders_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class OrdersController < ApplicationController
+    wrap_parameters false
+
+    skip_before_action :setup_tracking, only: :order_completed
+
+    # proxy enpoint between flow and thankyou page.
+    # /flow/order_completed endpoint
+    def order_completed
+      order = Spree::Order.find_by number: params[:order], guest_token: params[:t]
+
+      flow_updater = FlowcommerceSpree::OrderUpdater.new(order: order)
+      flow_updater.complete_checkout
+
+      redirect_to "/thankyou?order=#{params[:order]}&t=#{params[:t]}"
+    end
+  end
+end

data/app/controllers/flowcommerce_spree/webhooks_controller.rb

@@ -2,24 +2,34 @@
 
 module FlowcommerceSpree
   class WebhooksController < ActionController::Base
+    wrap_parameters false
     respond_to :json
+    http_basic_authenticate_with name: FLOW_IO_WEBHOOK_USER, password: FLOW_IO_WEBHOOK_PASSWORD
 
-    # forward all incoming requests to Flow WebhookService object
+    # forward incoming requests to respective Flow Webhooks Service objects
     # /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?
+    def handle_flow_io_event
+      %i[event_id organization discriminator].each_with_object(params) { |key, obj| obj.require(key) }
+      return unless organization_valid?
+
+      webhook_result = "FlowcommerceSpree::Webhooks::#{params['discriminator'].classify}".constantize.process(params)
+      @result = {}
+      @result[:error] = webhook_result.full_messages.join("\n") if webhook_result.errors.any?
     rescue StandardError => e
-      result = { error: e.class.to_s, message: e.message, backtrace: e.backtrace }
+      @result = { error: e.class.to_s, message: e.message, backtrace: e.backtrace }
     ensure
-      response_status = if result[:error]
-                          logger.info(result)
-                          :unprocessable_entity
-                        else
-                          :ok
-                        end
-      render json: result.except(:backtrace), status: response_status
+      logger.info(@result) if (error = @result[:error])
+      render json: @result.except(:backtrace), status: error ? :unprocessable_entity : :ok
+    end
+
+    private
+
+    def organization_valid?
+      org = params[:organization]
+      return true if org == FlowcommerceSpree::ORGANIZATION
+
+      @result = { error: 'InvalidParam', message: "Organization '#{org}' is invalid!" }
+      false
     end
   end
 end

data/app/controllers/users/sessions_controller_decorator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Users
+  SessionsController.class_eval do
+    # This endpoint is for returning to the FrontEnd the dynamic url to an external checkout, a flow.io url.
+    def checkout_url
+      flow_session_id = request.headers['flow-session-id']
+      return render json: { error: :session_id_missing }, status: 422 if flow_session_id.blank?
+
+      checkout_token =
+        FlowcommerceSpree::OrderSync.new(order: current_order, flow_session_id: flow_session_id).synchronize!
+      return render json: { error: :checkout_token_missing }, status: 422 if checkout_token.blank?
+
+      render json: { checkout_url: "https://checkout.flow.io/tokens/#{checkout_token}" }, status: 200
+    end
+
+    private
+
+    def add_optional_attrs(session_current)
+      session_current['user'] = current_user_attrs if current_user&.spree_api_key?
+      session_current['region'] = zone_attrs
+
+      external_checkout = current_zone.flow_io_active_experience?
+      session_current['external_checkout'] = external_checkout
+      session_current['flow_session_id'] = session['flow_session_id'] if external_checkout
+    end
+  end
+end

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

@@ -12,16 +12,11 @@ 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']
-            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
+          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
-            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'],
+        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].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