flowcommerce_spree 0.0.1 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6893ddfb8f021ff6400c0bbe31fc6b2c532886892730a1c9097d172944a8eca8
-  data.tar.gz: 9d3a1b190708053a5ad664588abe553617cf07a02ce6fb8f8b2b9d8d17b393a7
+  metadata.gz: ff1a7f69451b03b52d6422015450255988ac45f664a1bee62559e238e45f0a6b
+  data.tar.gz: d9fab8b6b5091b70235cde18b88dd0dc0988ed0d38946571236d9a828b0e6750
 SHA512:
-  metadata.gz: 531a87c9a666b3057d16983c3e6168492ac124112a881821891e3bb2174f7e5589785301e023348f3bb06ef2ea105961f20a6a2aaa884e9845e92896973586d7
-  data.tar.gz: c84a3cb370744c3313b04cdc513d38d70ea0aaa01e7e09470bdf768f77d41fdb0c4bb9df240bbe4fec58adc4068b96d64fa538a315d73e8a361a1f718ecc6b46
+  metadata.gz: 73f135866d3644fc4b9a92bc8003d88c28bdf220612e4823d2d1f04e190f3e0888f00c995e215b7efc9ebfa81bd9720b47b00e8f796bdad6b68391bb1852ec59
+  data.tar.gz: 8b2c6fe4c1d2987f4c467fb2f33afee8d0b4e15b7b6a12dddb44b28ab57c538e8c1dd9608604deca5170d70adfc011b0299ba00c7ba33c5b966a959878355a79

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
     ```
 
@@ -57,35 +71,98 @@ All flowcommerce_spree code is located in the ./app and ./lib folders.
   `serialize :flow_data, ActiveRecord::Coders::JSON.new(symbolize_keys: true)`
  
 
+## FlowcommerceSpree::Api module
 
-## Flow API specific
-
-Classes that begin with Flow are responsible for communicating with flow API.
-
-### Flow
-
-Helper class that offers low level flow api access and few helper methods.
+This is a legacy module using the `curl` gem for making direct calls to flow.io API. It will be refactored out in 
+future versions of the gem in favor of using the official flow.io API client from the `flowcommerce` gem.
 
 ### FlowcommerceSpree::ExperienceService
 
 Responsible for selecting current experience. You have to define available experiences in flow console.
 
-### Flow::Order
+### FlowcommerceSpree::OrderSync
 
 Maintain and synchronizes Spree::Order with Flow API.
 
-### Flow::Session
+### FlowcommerceSpree::Session
 
 Every shop user has a session. This class helps in creating and maintaining session with Flow.
 
-## Decorators
+### Decorators
+
+Decorators are used extensively across the gem to modify or add behaviour of several Spree classes and modules. To 
+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::Gateway::FlowIo
+
+Adapter for Spree, that allows using [Flow.io](https://www.flow.io) as payment gateway. 
+Flow is PCI compliant payment processor.
+
+
+## Gem Maintenance
+
+### Preparing a release
+
+Merge all the pull requests that should make it into the new release into the `main` branch, then checkout and pull the 
+branch and run the `github_changelog_generator`, specifying the new version as a `--future-release` cli parameter:
+
+```
+git checkout main
+git pull
+
+github_changelog_generator -u mejuri-inc -p flowcommerce_spree --future-release v0.0.2
+```
+
+Then add the changes to `git`, commit and push the `Preparing the new release` commit directly into the `main` branch:
+
+```
+git add .
+git commit -m 'Preparing the new v0.0.2 release'
+git push
+```
+
+### RubyGems credentials
+
+Ensure you have the RubyGems credentials located in the `~/.gem/credentials` file.
+
+### Adding a gem owner
+
+```
+gem owner flowcommerce_spree -a sebastian.deluca@mejuri.com
+```
+
+### Building a new gem version
+
+Adjust the new gem version number in the `lib/flowcommerce_spree/version.rb` file. It is used when building the gem 
+by the following command:
+
+```
+gem build flowcommerce_spree.gemspec
+```
+
+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
 
-Decorators are found in ./app/flow/decorators folders and they decorate Spree models with Flow specific methods.
+```
+gem push flowcommerce_spree-0.0.1.gem # don't forget to specify the correct version number
+```
 
-All methods are prefixed with ```flow_```.
+### Crafting the new release on GitHub
 
-## Helper lib
+On the [Releases page](https://github.com/mejuri-inc/flowcommerce_spree/releases) push the `Draft a new release` button.
 
-### Spree::Flow::Gateway
+The new release editing page opens, on which the following actions could be taken:
 
-Adapter for Spree, that allows using [Flow.io](https://www.flow.io) as payment gateway. Flow is PCI compliant payment processor.
+- 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,53 @@
 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
+    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)
+
+    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 +61,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?