flowcommerce_spree 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6893ddfb8f021ff6400c0bbe31fc6b2c532886892730a1c9097d172944a8eca8
+  data.tar.gz: 9d3a1b190708053a5ad664588abe553617cf07a02ce6fb8f8b2b9d8d17b393a7
+SHA512:
+  metadata.gz: 531a87c9a666b3057d16983c3e6168492ac124112a881821891e3bb2174f7e5589785301e023348f3bb06ef2ea105961f20a6a2aaa884e9845e92896973586d7
+  data.tar.gz: c84a3cb370744c3313b04cdc513d38d70ea0aaa01e7e09470bdf768f77d41fdb0c4bb9df240bbe4fec58adc4068b96d64fa538a315d73e8a361a1f718ecc6b46

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Aurel Branzeanu
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+<img src="https://i.imgur.com/tov8bTw.png" alt="flowcommerce_spree" style="float:right">
+
+# Flow.io < - > Spree adapter
+
+All flowcommerce_spree code is located in the ./app and ./lib folders.
+
+## Installation
+- Add the gem to main application's Gemfile:
+
+    ```
+    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:
+
+    ```
+    gem 'activerecord-postgres-json', git: 'https://github.com/mejuri-inc/activerecord-postgres-json'
+    ```
+ 
+
+- Run `bundle install`.
+
+- Define this additional ENV variables. You will find them 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 only piece of code that is needed to enable payments with the FlowCommerce engine
+
+    ```
+      # config/application.rb
+      config.after_initialize do |app|
+        # init Flow payments as an option
+        app.config.spree.payment_methods << Spree::Gateway::Flow
+      end
+    ```
+
+- To see and optionally invoke the list of FlowCommerce tasks, run `bundle exec rake flowcommerce_spree:list_tasks
+`. Any task from the list could be invoked, typing at the `Type the task number to be invoked:` prompt the task
+ number, or from a terminal prompt, in the main application's root folder,  running `bundle exec rake {task_name}` 
+ 
+- Run the `flowcommerce_spree:install:migrations` task to copy the DB migrations' file into the main application's
+ `db/migrate` folder. 
+
+- Run `bundle exec rake db:migrate SCOPE=flowcommerce_spree
+` from a terminal prompt. This will add an `meta` jsonb column to the Spree::CreditCard, Spree::Product, 
+  Spree::Variant, Spree::Order, Spree::Promotion models' DB tables, if there is not yet such a column defined.
+
+- If the main application's Rails version is less than 4.2, add the JSON serializer for the `meta` column to the
+ affected models' decorators (Spree::CreditCard, Spree::Product, Spree::Variant, Spree::Order, Spree::Promotion models):
+  
+  `serialize :flow_data, ActiveRecord::Coders::JSON.new(symbolize_keys: true)`
+ 
+
+
+## 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.
+
+### FlowcommerceSpree::ExperienceService
+
+Responsible for selecting current experience. You have to define available experiences in flow console.
+
+### Flow::Order
+
+Maintain and synchronizes Spree::Order with Flow API.
+
+### Flow::Session
+
+Every shop user has a session. This class helps in creating and maintaining session with Flow.
+
+## Decorators
+
+Decorators are found in ./app/flow/decorators folders and they decorate Spree models with Flow specific methods.
+
+All methods are prefixed with ```flow_```.
+
+## Helper lib
+
+### Spree::Flow::Gateway
+
+Adapter for Spree, that allows using [Flow.io](https://www.flow.io) as payment gateway. Flow is PCI compliant payment processor.

data/Rakefile

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'FlowcommerceSpree'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/SPREE_FLOW.md

@@ -0,0 +1,134 @@
+# Flow, ActiveMerchant and Spree integration
+
+Integration of Spree with Flow, how it is done.
+
+I plan to be concise as possible, but cover all important topics.
+
+## 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:
+
+```
+# ./config/initializers/flowcommerce_spree.rb
+
+FlowcommerceSpree.configure do |c|
+  c.experience_associator = FlowcommerceSpree::ExperienceAssociator
+end
+```
+
+### 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
+to maintain sessions and orders in Flow, you have to do it outside the ActiveMerchant
+terminology which focuses around purchases, voids and refunds.
+
+Another thing to have in mind is that Spree can't work with ActiveMerchant directly, it has to have
+an adapter. Adapter can be "stupid" and light, and can forward all the "heavy lifting" to ActiveMerchant gem
+but it can also have all the logic localy.
+
+In http://guides.spreecommerce.org/developer/payments.html at the bottom of the page Spree authors say
+
+"better_spree_paypal_express and spree-adyen are good examples of standalone
+custom gateways. No dependency on spree_gateway or activemerchant required."
+
+Reading that we can see this is even considered good approach. For us, this is a possibility
+but we consume ActiveMerchatFlow gem.
+
+## ActiveMerchant gem into more detail
+
+https://github.com/flowcommerce/active_merchant
+
+Sopporst stanard public ActiveMerchant actions which are
+purchase, authorize, capture, void, store and refund.
+
+It depends on following gems
+
+* flowcommerce   - api calls
+* flow-reference - we use currency validations
+
+It is not aware of Spree or any other shopping lib or framework.
+
+### ActiveMerchant::Flow supported actions in detail
+
+* purchase  - shortcut for authorize and then capture
+* authorize - authorize the cc and funds.
+* capture   - capture the funds
+* void      - cancel the transaction
+* store     - store credit card (gets credit card flow token)
+* refund    - refund the funds
+
+## Spree Implementation in more detail
+
+Not present as standalone gem, yet. I will do that once we agree on implementation details.
+
+From product list to purchase, complete chain v1
+
+1. customer has to prepare data, migrate db and connect to Flow. In general
+  * create experiences in Flow console, add tiers, shipping methods, etc.
+  * add flow_data (jsonb) fields to this models
+    * Spree::Variant - we cache localized product prices
+    * Spree::Order   - we cache flow order state details, shipping method
+  * create and sync product catalog via rake tasks
+1. now site users can browse prooducts and add them to cart.
+1. when user comes to shop, FlowSession is created
+1. once product is in cart
+  * spree order is created and linked to Experience that we get from FlowSession
+  * it is captured and synced with flow, realtime
+    * we do this all the time because we want to have 100% accurate prices.
+      Product prices that are shown in cart come directly from Flow API.
+  * in checkout, when customer address is added or shipping method defined,
+    all is synced with flow order.
+  * when order is complete, we trigger flow-cc-authorize or flow-cc-capture directly
+    on Spree::Order object instance. This is good because all gateway actions
+    are functions of the order object anyway.
+    * flow-cc-authorize or flow-cc-capture use ActiveMerchantFlow to execute this actions
+    * ActiveMerchantFlow included flow-reference gem
+
+## What can be better
+
+We need a way to access the order in Rails. Access it after it is created in
+controller but before it hits the render.
+Current implementation is -> "overload" ApplicationController render
+If we detect @spree_order object or debug flags, we react.
+
+* good    - elegant solution, all need code is in one file in few lines of code
+* bad     - somehow intrusive, we overload render, somw people will not like that.
+* alternatives: gem that allows before_render bethod, call explicitly when needed
+
+## Aditional notes - view and frontend
+
+I see many Spree merchant gems carry frontend code, js, coffe, views etc.
+I thing that this is bad practise and that shop frontend has to be 100% customer code.
+
+What I did not see but thing is great idea is to have custom light Flow admin present at
+
+/admin/flow
+
+that will ease the way of working with Flow. Code can be made to be Rails 4 and Rails 5 compatibile.
+Part of that is allready done as can be seen here [Flow admin screenshot](https://i.imgur.com/FXbPrwK.png)
+
+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/assets/javascripts/flowcommerce_spree/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/flowcommerce_spree/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/concerns/current_zone_loader_decorator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+CurrentZoneLoader.module_eval do
+  extend ActiveSupport::Concern
+
+  def flow_zone # rubocop:disable Metrics/MethodLength, 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)
+    # :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
+    zone
+  end
+
+  # composes an unique vistor id for FlowcommerceSpree::Session model
+  def visitor_id_for_flow_io
+    guest_token = cookies.signed[:guest_token]
+    uid = if guest_token
+            Digest::SHA1.hexdigest(guest_token)
+          else
+            session_id = session[:session_id]
+            session_id ? Digest::SHA1.hexdigest(session_id) : Digest::SHA1.hexdigest(request.ip + request.user_agent)
+          end
+
+    "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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class WebhooksController < ActionController::Base
+    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?
+    rescue StandardError => e
+      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
+    end
+  end
+end

data/app/helpers/flowcommerce_spree/application_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  module ApplicationHelper
+  end
+end

data/app/helpers/spree/admin/orders_helper_decorator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Flow (2017)
+# Enable this modifications if you want to display flow localized line item shipment price beside Spree default
+# Example: https://i.imgur.com/7v2ix2G.png
+module Spree
+  module Admin
+    OrdersHelper.module_eval do
+      # admin show line item total price
+      def line_item_shipment_price(line_item, quantity)
+        price = Spree::Money.new(line_item.price * quantity, currency: line_item.currency).to_s
+        price += " (#{@order.flow_line_item_price(line_item, quantity)})" if @order.flow_order
+        price.html_safe
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    module ControllerHelpers
+      # Spree::Core::ControllerHelpers::Order decorator to inject Flow.io Experience into the order, if such an
+      # Experience is present in the Order's zone
+      module FlowIoOrderHelperDecorator
+        private
+
+        def adjust_zone_and_ip
+          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
+            end
+            update_meta = true
+          end
+
+          if @current_order.new_record?
+            @current_order.last_ip_address = ip_address
+            return @current_order.save
+          end
+
+          attrs_to_update = {}
+
+          # Update last_ip_address only for a new request_id
+          attrs_to_update = { last_ip_address: ip_address } if @request_id != request_id
+
+          # :meta is a jsonb column costly to update every time, especially with all the flow.io data, that's why
+          # here it is updated only if no zone_id there was inside :meta
+          attrs_to_update[:meta] = @current_order.meta.to_json if update_meta
+
+          @current_order.update_columns(attrs_to_update) if attrs_to_update.present?
+          attrs_to_update
+        end
+
+        def request_id
+          @request_id ||= env['action_dispatch.request_id']
+        end
+
+        ApplicationController.prepend(self) if ApplicationController.included_modules.exclude?(self)
+      end
+    end
+  end
+end