flowcommerce_spree 0.0.2 → 0.0.7

data/app/services/flowcommerce_spree/webhooks/card_authorization_upserted_v2.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  module Webhooks
+    class CardAuthorizationUpsertedV2
+      attr_reader :errors
+      alias full_messages errors
+
+      def self.process(data)
+        new(data).process
+      end
+
+      def initialize(data)
+        @data = data['authorization']&.to_hash
+        @data&.[]('method')&.delete('images')
+        @errors = []
+      end
+
+      def process
+        errors << { message: 'Authorization param missing' } && (return self) unless @data
+
+        errors << { message: 'Card param missing' } && (return self) unless (flow_io_card = @data.delete('card'))
+
+        if (order_number = @data.dig('order', 'number'))
+          if (order = Spree::Order.find_by(number: order_number))
+            card = upsert_card(flow_io_card, order)
+
+            order.payments.where(response_code: @data['id'])
+                 .update_all(source_id: card.id, source_type: 'Spree::CreditCard')
+
+            return card
+          else
+            errors << { message: "Order #{order_number} not found" }
+          end
+        else
+          errors << { message: 'Order number param missing' }
+        end
+
+        self
+      end
+
+      private
+
+      def upsert_card(flow_io_card, order)
+        flow_io_card_expiration = flow_io_card.delete('expiration')
+
+        card = Spree::CreditCard.find_or_initialize_by(month: flow_io_card_expiration['month'].to_s,
+                                                       year: flow_io_card_expiration['year'].to_s,
+                                                       cc_type: flow_io_card.delete('type'),
+                                                       last_digits: flow_io_card.delete('last4'),
+                                                       name: flow_io_card.delete('name'),
+                                                       user_id: order.user&.id)
+        card.flow_data ||= {}
+        if card.new_record?
+          card.flow_data.merge!(flow_io_card.except('discriminator'))
+          card.imported = true
+        end
+
+        card.push_authorization(@data.except('discriminator'))
+        card.new_record? ? card.save : card.update_column(:meta, card.meta.to_json)
+
+        card
+      end
+    end
+  end
+end

data/app/services/flowcommerce_spree/webhooks/experience_upserted_v2.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  module Webhooks
+    class ExperienceUpsertedV2
+      attr_accessor :errors
+      alias full_messages errors
+
+      def self.process(data, opts = {})
+        new(data, opts).process
+      end
+
+      def initialize(data, opts = {})
+        @data = data
+        @opts = opts
+        @errors = []
+      end
+
+      def process
+        experience = @data['experience']
+        Spree::Zones::Product.find_or_initialize_by(name: experience['key'].titleize).store_flow_io_data(experience)
+      end
+    end
+  end
+end

data/app/services/flowcommerce_spree/webhooks/fraud_status_changed.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  module Webhooks
+    class FraudStatusChanged
+      attr_accessor :errors
+      alias full_messages errors
+
+      def self.process(data, opts = {})
+        new(data, opts).process
+      end
+
+      def initialize(data, opts = {})
+        @data = data
+        @opts = opts
+        @errors = []
+      end
+
+      def process
+        order_number = @data.dig('order', 'number')
+        errors << { message: 'Order number param missing' } && (return self) unless order_number
+
+        order = Spree::Order.find_by(number: order_number)
+        errors << { message: "Order #{order_number} not found" } && (return self) unless order
+
+        if @data['status'] == 'declined'
+          order.update_columns(fraudulent: true)
+          order.cancel!
+        end
+
+        order
+      end
+    end
+  end
+end

data/app/services/flowcommerce_spree/webhooks/local_item_upserted.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  module Webhooks
+    class LocalItemUpserted
+      attr_accessor :errors
+      alias full_messages errors
+
+      def self.process(data, opts = {})
+        new(data, opts).process
+      end
+
+      def initialize(data, opts = {})
+        @data = data
+        @opts = opts
+        @errors = []
+      end
+
+      def process
+        errors << { message: 'Local item param missing' } && (return self) unless (local_item = @data['local_item'])
+
+        errors << { message: 'SKU param missing' } && (return self) unless (flow_sku = local_item.dig('item', 'number'))
+
+        if (variant = Spree::Variant.find_by(sku: flow_sku))
+          variant.add_flow_io_experience_data(
+            local_item.dig('experience', 'key'),
+            'prices' => [local_item.dig('pricing', 'price')], 'status' => local_item['status']
+          )
+
+          variant.update_column(:meta, variant.meta.to_json)
+          return variant
+        else
+          errors << { message: "Variant with sku [#{flow_sku}] not found!" }
+        end
+
+        self
+      end
+    end
+  end
+end

data/app/views/spree/admin/payments/source_views/_flow_io_gateway.html.erb

@@ -0,0 +1,21 @@
+<fieldset data-hook="credit_card">
+  <legend align="center"><%= Spree.t(:credit_card) %></legend>
+
+  <div class="row">
+    <div class="alpha six columns">
+      <dl>
+        <dt><%= Spree.t(:name_on_card) %>:</dt>
+        <dd><%= payment.source&.name %></dd>
+
+        <dt><%= Spree.t(:card_type) %>:</dt>
+        <dd><%= payment.source&.cc_type %></dd>
+
+        <dt><%= Spree.t(:card_number) %>:</dt>
+        <dd><%= payment.source&.display_number %></dd>
+
+        <dt><%= Spree.t(:expiration) %>:</dt>
+        <dd><%= payment.source&.month %>/<%= payment.source&.year %></dd>
+      </dl>
+    </div>
+  </div>
+</fieldset>

data/config/rails_best_practices.yml

@@ -0,0 +1,51 @@
+AddModelVirtualAttributeCheck: { }
+AlwaysAddDbIndexCheck: { }
+#CheckSaveReturnValueCheck: { }
+#CheckDestroyReturnValueCheck: { }
+DefaultScopeIsEvilCheck: { }
+DryBundlerInCapistranoCheck: { }
+#HashSyntaxCheck: { }
+IsolateSeedDataCheck: { }
+KeepFindersOnTheirOwnModelCheck: { }
+LawOfDemeterCheck: { }
+#LongLineCheck: { max_line_length: 80 }
+MoveCodeIntoControllerCheck: { }
+MoveCodeIntoHelperCheck: { array_count: 3 }
+MoveCodeIntoModelCheck: { use_count: 2 }
+MoveFinderToNamedScopeCheck: { }
+MoveModelLogicIntoModelCheck: { use_count: 4 }
+NeedlessDeepNestingCheck: { nested_count: 2 }
+NotRescueExceptionCheck: { }
+NotUseDefaultRouteCheck: { }
+NotUseTimeAgoInWordsCheck: { }
+OveruseRouteCustomizationsCheck: { customize_count: 3 }
+ProtectMassAssignmentCheck: { }
+RemoveEmptyHelpersCheck: { }
+#RemoveTabCheck: { }
+RemoveTrailingWhitespaceCheck: { }
+RemoveUnusedMethodsInControllersCheck: { except_methods: [] }
+RemoveUnusedMethodsInHelpersCheck: { except_methods: [] }
+RemoveUnusedMethodsInModelsCheck: { except_methods: 
+  [
+  'Spree::Calculator::FlowIo#compute_shipment', # Used by Spree::Calculator
+  'Spree::Calculator::FlowIo#compute_line_item', # Used by Spree::Calculator
+  'Spree::Calculator::FlowIo#description', # Used by Spree
+  'Spree::Shipping::FlowIo#compute_package', # Used by Spree
+  'Spree::Shipping::FlowIo#default_charge', # Used by Spree
+  'Spree::Shipping::FlowIo#threshold', # Used by Spree
+  'Spree::Shipping::FlowIo#description', # Used by Spree
+  ] }
+ReplaceComplexCreationWithFactoryMethodCheck: { attribute_assignment_count: 2 }
+ReplaceInstanceVariableWithLocalVariableCheck: { }
+RestrictAutoGeneratedRoutesCheck: { }
+SimplifyRenderInControllersCheck: { }
+SimplifyRenderInViewsCheck: { }
+#UseBeforeFilterCheck: { customize_count: 2 }
+UseModelAssociationCheck: { }
+UseMultipartAlternativeAsContentTypeOfEmailCheck: { }
+#UseParenthesesInMethodDefCheck: { }
+UseObserverCheck: { }
+UseQueryAttributeCheck: { }
+UseSayWithTimeInMigrationsCheck: { }
+UseScopeAccessCheck: { }
+UseTurboSprocketsRails3Check: { }

data/config/routes.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 FlowcommerceSpree::Engine.routes.draw do
-  post '/event-target', to: 'webhooks#handle_flow_web_hook_event'
+  post '/event-target', to: 'webhooks#handle_flow_io_event'
+  get '/order-completed', to: 'orders#order_completed'
+  post '/online-stock-availability', to: 'inventory#online_stock_availability'
 end

data/db/migrate/20201021755957_add_meta_to_spree_tables.rb

@@ -5,13 +5,15 @@ class AddMetaToSpreeTables < ActiveRecord::Migration
     add_column :spree_orders, :meta, :jsonb, default: '{}' unless column_exists?(:spree_orders, :meta)
     add_column :spree_promotions, :meta, :jsonb, default: '{}' unless column_exists?(:spree_promotions, :meta)
     add_column :spree_credit_cards, :meta, :jsonb, default: '{}' unless column_exists?(:spree_credit_cards, :meta)
+    add_column :spree_payment_capture_events, :meta, :jsonb, default: '{}' unless column_exists?(:spree_payment_capture_events, :meta)
   end
 
   def down
-    remove_column :spree_products, :meta if column_exists?(:spree_products, :meta)
-    remove_column :spree_variants, :meta if column_exists?(:spree_variants, :meta)
-    remove_column :spree_orders, :meta if column_exists?(:spree_orders, :meta)
-    remove_column :spree_promotions, :meta if column_exists?(:spree_promotions, :meta)
+    remove_column :spree_payment_capture_events, :meta if column_exists?(:spree_payment_capture_events, :meta)
     remove_column :spree_credit_cards, :meta if column_exists?(:spree_credit_cards, :meta)
+    remove_column :spree_promotions, :meta if column_exists?(:spree_promotions, :meta)
+    remove_column :spree_orders, :meta if column_exists?(:spree_orders, :meta)
+    remove_column :spree_variants, :meta if column_exists?(:spree_variants, :meta)
+    remove_column :spree_products, :meta if column_exists?(:spree_products, :meta)
   end
 end

data/lib/flow/simple_gateway.rb

@@ -34,42 +34,6 @@ module Flow
       error_response(e)
     end
 
-    # capture authorised funds
-    def cc_capture
-      # GET /:organization/authorizations, order_number: abc
-      data = @order.flow_data['authorization']
-
-      raise ArgumentError, 'No Authorization data, please authorize first' unless data
-
-      capture_form = ::Io::Flow::V0::Models::CaptureForm.new(data)
-      response = FlowcommerceSpree.client.captures.post(FlowcommerceSpree::ORGANIZATION, capture_form)
-
-      return ActiveMerchant::Billing::Response.new false, 'error', response: response unless response.id
-
-      @order.update_column :flow_data, @order.flow_data.merge('capture': response.to_hash)
-      @order.flow_finalize!
-
-      ActiveMerchant::Billing::Response.new true, 'success', response: response
-    rescue StandardError => e
-      error_response(e)
-    end
-
-    def cc_refund
-      raise ArgumentError, 'capture info is not available' unless @order.flow_data['capture']
-
-      # we allways have capture ID, so we use it
-      refund_data = { capture_id: @order.flow_data['capture']['id'] }
-      refund_form = ::Io::Flow::V0::Models::RefundForm.new(refund_data)
-      response    = FlowcommerceSpree.client.refunds.post(FlowcommerceSpree::ORGANIZATION, refund_form)
-
-      return ActiveMerchant::Billing::Response.new false, 'error', response: response unless response.id
-
-      @order.update_column :flow_data, @order.flow_data.merge('refund': response.to_hash)
-      ActiveMerchant::Billing::Response.new true, 'success', response: response
-    rescue StandardError => e
-      error_response(e)
-    end
-
     private
 
     # if order is not in flow, we use local Spree settings

data/lib/flowcommerce_spree.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
 
+require 'activerecord-postgres-json'
+require 'active_model_serializers'
 require 'flowcommerce'
 require 'flowcommerce_spree/api'
 require 'flowcommerce_spree/refresher'
 require 'flowcommerce_spree/engine'
 require 'flowcommerce_spree/logging_http_client'
 require 'flowcommerce_spree/logging_http_handler'
-require 'flowcommerce_spree/webhook_service'
 require 'flowcommerce_spree/session'
 require 'flow/simple_gateway'
+require 'oj'
 
 module FlowcommerceSpree
+  API_KEY = ENV.fetch('FLOW_TOKEN', 'test_key')
+  ENV['FLOW_TOKEN'] = API_KEY
+
   def self.client(logger: FlowcommerceSpree.logger, **opts)
     FlowCommerce.instance(http_handler: LoggingHttpHandler.new(logger: logger), **opts)
   end
@@ -20,11 +25,20 @@ module FlowcommerceSpree
   end
 
   def self.logger
-    logger = ActiveSupport::Logger.new(STDOUT, 3, 10_485_760)
+    logger = ActiveSupport::Logger.new(STDOUT)
+
+    logger_formatter = proc do |severity, datetime, _progname, msg|
+      "\n#{datetime}, #{severity}: #{msg}\n"
+    end
+
+    logger.formatter = logger_formatter
 
     # Broadcast the log into the file besides STDOUT, if `log` folder exists
     if Dir.exist?('log')
-      logger.extend(ActiveSupport::Logger.broadcast(ActiveSupport::Logger.new('log/flowcommerce_spree.log')))
+      file_logger = ActiveSupport::Logger.new('log/flowcommerce_spree.log', 3, 10_485_760)
+      file_logger.formatter = logger_formatter
+
+      logger.extend(ActiveSupport::Logger.broadcast(file_logger))
     end
     logger
   end

data/lib/flowcommerce_spree/engine.rb

@@ -6,22 +6,52 @@ module FlowcommerceSpree
     isolate_namespace FlowcommerceSpree
 
     config.before_initialize do
+      FlowcommerceSpree::ORGANIZATION = ENV.fetch('FLOW_ORGANIZATION', 'flow.io')
+      FlowcommerceSpree::BASE_COUNTRY = ENV.fetch('FLOW_BASE_COUNTRY', 'USA')
+      FlowcommerceSpree::API_KEY = ENV.fetch('FLOW_TOKEN', 'test_key')
+      FlowcommerceSpree::FLOW_IO_WEBHOOK_USER = ENV.fetch('FLOW_IO_WEBHOOK_USER', 'test_user')
+      FlowcommerceSpree::FLOW_IO_WEBHOOK_PASSWORD = ENV.fetch('FLOW_IO_WEBHOOK_PASSWORD', 'test_password')
+
       FlowcommerceSpree::Config = FlowcommerceSpree::Settings.new
     end
 
-    config.after_initialize do
+    config.flowcommerce_spree = ActiveSupport::OrderedOptions.new
+
+    initializer 'flowcommerce_spree.configuration' do |app|
+      # If some Rake tasks will fail in development environment, the cause could be the autoloading.
+      # Uncommenting the following 3 lines will enable eager-loading for the flowcommerce_spree Rake tasks.
+      # if Rails.env.development?
+      #   app.config.eager_load = Rake.application.top_level_tasks.any? { |t| t.start_with?('flowcommerce_spree') }
+      # end
+
+      app.config.flowcommerce_spree[:mounted_path] = ENV.fetch('FLOW_MOUNT_PATH', '/flow')
+
+      app.routes.prepend do
+        mount FlowcommerceSpree::Engine => app.config.flowcommerce_spree[:mounted_path]
+      end
+    end
+
+    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
 
-      Flow::SimpleGateway.clear_zero_amount_payments = true
+      # Flow::SimpleGateway.clear_zero_amount_payments = true
     end
 
     def self.activate
       Dir.glob(File.join(File.dirname(__FILE__), '../../app/**/*_decorator*.rb')).sort.each do |c|
         Rails.configuration.cache_classes ? require(c) : load(c)
       end
+      Dir.glob(File.join(File.dirname(__FILE__), '../app/overrides/*.rb')).sort.each do |c|
+        Rails.configuration.cache_classes ? require(c) : load(c)
+      end
     end
 
     config.to_prepare(&method(:activate).to_proc)
+
+    initializer 'spree.flowcommerce_spree.calculators', after: 'spree.register.calculators' do |_app|
+      Rails.application.config.spree.calculators.tax_rates << Spree::Calculator::FlowIo
+      Rails.application.config.spree.calculators.shipping_methods << Spree::Calculator::Shipping::FlowIo
+    end
   end
 end

data/lib/flowcommerce_spree/experience_service.rb

@@ -22,18 +22,6 @@ module FlowcommerceSpree
       nil
     end
 
-    def get_by_subcatalog_id(subcatalog_id)
-      fetch_from_flow.each do |experince|
-        return experince if experince.subcatalog.id == subcatalog_id
-      end
-
-      nil
-    end
-
-    def compact
-      all.map { |exp| [exp.country, exp.key, exp.name] }
-    end
-
     def default
       FlowcommerceSpree::ExperienceService
         .all.select { |exp| exp.key.downcase == ENV.fetch('FLOW_BASE_COUNTRY').downcase }.first
@@ -42,24 +30,10 @@ module FlowcommerceSpree
     private
 
     def fetch_from_flow
-      # return cached_experinces if cache_valid?
-
-      experiences = FlowcommerceSpree.client.experiences.get ORGANIZATION
+      FlowcommerceSpree.client.experiences.get ORGANIZATION
 
       # work with active axperiences only
       # experiences = experiences.select { |it| it.status.value == 'active' }
-
-      # @cache = [experiences, Time.now]
-      experiences
-    end
-
-    def cache_valid?
-      # cache experinces in worker memory for 1 minute
-      @cache && @cache[1] > Time.now.ago(1.minute)
-    end
-
-    def cached_experinces
-      @cache[0]
     end
   end
 end