flowcommerce_spree 0.0.3 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51a668ee3cc70d0bc9bd8c7662a972f086e06dcdcf4c68df2177e94818dfb820
-  data.tar.gz: aa9ff17e57cd19452736af11d51bd1905c4dd7e66bb461b5dff017fc5dea0b0d
+  metadata.gz: c89d8869da7867a7ae0400dab1005c763c5c98f001336bf915f14743bd279c7a
+  data.tar.gz: f664b4f9f7380860b5c5eec7cf5aeda85d59c8b6d2753830f553ccc8734718c4
 SHA512:
-  metadata.gz: 024a29a6fc47f932e432f2477f9a1f3b520af7cc10b7a85eb35613328276d5390a682187151217c0527b20435431f78e8cc55255d95298620bfb5077c7ed5011
-  data.tar.gz: b6d9485612e360ed50caabfab537baf9583feec384607b4a890c1ab1fd9fc48cd9ea3954562aac828f4a858682ad1515ae7f2b9bf05a8a501ff8abf96c28f972
+  metadata.gz: f32478dce9ed19e62ddb9955a0e0d8f7b7388eb9c5079be107282306c85ab524b49f83b35cff0d5835fc79c485d0dd3fc15cb924969ba250dd80182dfb6242c4
+  data.tar.gz: b1e68c45f17888c1d717001a2a352957e04a4fb32c47d2864349299d868e01e0cbfd138f7ed599cd5c1a06e3847b4e4745d8630b0472d104c7eceabe6177f518

data/README.md

@@ -20,8 +20,15 @@ All flowcommerce_spree code is located in the ./app and ./lib folders.
 
 - Run `bundle install`.
 
-- 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):
+- 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
@@ -29,7 +36,10 @@ All flowcommerce_spree code is located in the ./app and ./lib folders.
     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' 
+    FLOW_MOUNT_PATH='/flow'
+    # The following variables should be set for securing the FlowcommerceSpree::WebhooksControler
+    FLOW_IO_WEBHOOK_USER
+    FLOW_IO_WEBHOOK_PASSWORD
     ```
 
 - To enable payments with the FlowCommerce engine, the payment method `flow.io` with `Spree::Gateway::FlowIo` should be 
@@ -86,7 +96,9 @@ 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.
+Adapter for Spree, that allows using [Flow.io](https://www.flow.io) as payment gateway. 
+Flow is PCI compliant payment processor.
+
 
 ## Gem Maintenance
 
@@ -129,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/app/controllers/concerns/current_zone_loader_decorator.rb

@@ -7,12 +7,14 @@ CurrentZoneLoader.module_eval do
     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
+                      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])
 
@@ -20,29 +22,21 @@ CurrentZoneLoader.module_eval do
     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
+  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.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
+    # 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['_f60_session'] = flow_io_session.id
-      session['_f60_expires_at'] = flow_io_session.expires_at.to_s
+      session['flow_session_id'] = flow_io_session.id
     end
 
     zone

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

@@ -4,34 +4,32 @@ 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
-      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
+    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 check_organization
+    def organization_valid?
       org = params[:organization]
-      return {} if org == FlowcommerceSpree::ORGANIZATION
+      return true if org == FlowcommerceSpree::ORGANIZATION
 
-      { error: 'InvalidParam', message: "Organization '#{org}' is invalid!" }
+      @result = { error: 'InvalidParam', message: "Organization '#{org}' is invalid!" }
+      false
     end
   end
 end

data/app/controllers/users/sessions_controller_decorator.rb

@@ -2,10 +2,27 @@
 
 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 external_checkout?
-      current_zone.flow_io_active_experience? ? 'true' : 'false'
+    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

@@ -17,22 +17,6 @@ module Spree
               @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']
-            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
           end
 
           if @current_order.new_record?

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/address_decorator.rb

@@ -11,7 +11,7 @@ module Spree
         address2: address_data['streets'][1],
         zipcode: address_data['postal'],
         city: address_data['city'],
-        state_name: address_data['province'] || 'something',
+        state_name: address_data['province'],
         country: Spree::Country.find_by(iso3: address_data['country'])
       }
     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)
@@ -32,28 +39,33 @@ module Spree
 
       def can_calculate_tax?(order)
         return false if order.flow_data.blank?
-        return false if %w[cart address delivery].include?(order.state)
+        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)
+          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/calculator/shipping/flow_io.rb

@@ -4,6 +4,9 @@ module Spree
   class Calculator
     module Shipping
       class FlowIo < ShippingCalculator
+        preference :lower_boundary, :decimal, default: 100
+        preference :charge_default, :decimal, default: 15
+
         def self.description
           'FlowIO Calculator'
         end
@@ -16,11 +19,11 @@ module Spree
         end
 
         def default_charge(_country)
-          0
+          preferred_charge_default
         end
 
         def threshold
-          0
+          preferred_lower_boundary
         end
 
         private

data/app/models/spree/flow_io_credit_card_decorator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Spree
+  module FlowIoCreditCardDecorator
+    def self.prepended(base)
+      base.serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
+
+      base.store_accessor :meta, :flow_data
+    end
+
+    def push_authorization(auth_hash)
+      self.flow_data ||= {}
+      flow_data['authorizations'] ||= []
+      card_authorizations = flow_data['authorizations']
+      card_authorizations.delete_if { |ca| ca['id'] == auth_hash['id'] }
+      card_authorizations << auth_hash
+    end
+
+    Spree::CreditCard.prepend(self) if Spree::CreditCard.included_modules.exclude?(self)
+  end
+end

data/app/models/spree/flow_io_order_decorator.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Spree
+  # Added flow specific methods to Spree::Order
+  module FlowIoOrderDecorator
+    def self.included(base)
+      base.serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
+
+      base.store_accessor :meta, :flow_data
+    end
+
+    def flow_tax_cache_key
+      [number, 'flowcommerce', 'allocation', line_items.sum(:quantity)].join('-')
+    end
+
+    def display_total
+      return unless flow_data&.[]('order')
+
+      Spree::Money.new(flow_io_total_amount, currency: currency)
+    end
+
+    def flow_order
+      flow_data&.[]('order')
+    end
+
+    def flow_order_with_payments?
+      payment = payments.completed.first
+
+      payment&.payment_method&.type == 'Spree::Gateway::FlowIo'
+    end
+
+    # accepts line item, usually called from views
+    def flow_line_item_price(line_item, total = false)
+      result = if (order = flow_order)
+                 item = order['lines']&.find { |el| el['item_number'] == line_item.variant.sku }
+
+                 return 'n/a' unless item
+
+                 total ? item['total']['label'] : item['price']['label']
+               else
+                 FlowcommerceSpree::Api.format_default_price(line_item.price * (total ? line_item.quantity : 1))
+               end
+
+      # add line item promo
+      # promo_total, adjustment_total
+      result += " (#{FlowcommerceSpree::Api.format_default_price(line_item.promo_total)})" if line_item.promo_total > 0
+
+      result
+    end
+
+    # shows localized total, if possible. if not, fall back to Spree default
+    def flow_io_total_amount
+      flow_data&.dig('order', 'total', 'amount')&.to_d || 0
+    end
+
+    def flow_io_experience_key
+      flow_data&.[]('exp')
+    end
+
+    def flow_io_experience_from_zone
+      self.flow_data = (flow_data || {}).merge!('exp' => zone.flow_io_experience)
+    end
+
+    def flow_io_order_id
+      flow_data&.dig('order', 'id')
+    end
+
+    def flow_io_attributes
+      flow_data&.dig('order', 'attributes') || {}
+    end
+
+    def flow_io_attribute_add(attr_key, value)
+      self.flow_data['order'] ||= {}
+      self.flow_data['order']['attributes'] ||= {}
+      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 || ''
+    end
+
+    def flow_io_attr_user_uuid
+      flow_data&.dig('order', 'attributes', 'user_uuid')
+    end
+
+    def flow_io_captures
+      flow_data&.[]('captures')
+    end
+
+    def flow_io_captures_sum
+      captures_sum = 0
+      flow_data&.[]('captures')&.each do |c|
+        next if c['status'] != 'succeeded'
+
+        amount = c['amount']
+        amount = amount.to_d if amount.is_a?(String)
+        captures_sum += amount
+      end
+      captures_sum.to_d
+    end
+
+    def flow_io_balance_amount
+      flow_data&.dig('order', 'balance', 'amount')&.to_d || 0
+    end
+
+    def flow_io_payments
+      flow_data.dig('order', 'payments')
+    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
+
+    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