flowcommerce_spree 0.0.1

data/lib/flowcommerce_spree/engine.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class Engine < ::Rails::Engine
+    require 'spree/core'
+    isolate_namespace FlowcommerceSpree
+
+    config.before_initialize do
+      FlowcommerceSpree::Config = FlowcommerceSpree::Settings.new
+    end
+
+    config.after_initialize do
+      # init Flow payments as an option
+      # app.config.spree.payment_methods << Spree::Gateway::Flow
+
+      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
+    end
+
+    config.to_prepare(&method(:activate).to_proc)
+  end
+end

data/lib/flowcommerce_spree/experience_service.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Communicates with flow.io API, easy access
+# to basic shop frontend and backend needs
+module FlowcommerceSpree
+  module ExperienceService
+    extend self
+
+    def all(no_world = nil)
+      experiences = fetch_from_flow
+      no_world ? experiences.reject { |exp| exp.key == 'world' } : experiences
+    end
+
+    def keys
+      all.map(&:key)
+    end
+
+    def get(key)
+      all.each do |exp|
+        return exp if exp.key == key
+      end
+      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
+    end
+
+    private
+
+    def fetch_from_flow
+      # return cached_experinces if cache_valid?
+
+      experiences = 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

data/lib/flowcommerce_spree/logging_http_client.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class LoggingHttpClient < ::Io::Flow::V0::HttpClient::DefaultHttpHandlerInstance
+    attr_reader :error
+
+    def initialize(base_uri, logger: FlowcommerceSpree.logger)
+      super(base_uri)
+      @logger = logger
+    end
+
+    def execute(request)
+      # original_open = client.open_timeout
+      # original_read = client.read_timeout
+
+      start_time = Time.now.utc.round(10)
+      @logger.info "start #{request.method} #{request.path}"
+      @logger.info "body: #{request.instance_variable_get(:@header)}"
+      @logger.info "body: #{request.body}"
+
+      if request.path.start_with?('/organizations')
+        # Contrived example to show how client settings can be adjusted
+        # client.open_timeout = 60
+        # client.read_timeout = 60
+      end
+
+      begin
+        response = super
+      rescue Io::Flow::V0::HttpClient::ServerError => e
+        @error = { error: e }.to_json
+      ensure
+        # client.open_timeout = original_open
+        # client.read_timeout = original_read
+
+        end_time = Time.now.utc.round(10)
+        duration = ((end_time - start_time) * 1000).round(0)
+        @logger.info "complete #{request.method} #{request.path} #{duration} ms"
+        @logger.info "response: #{response}"
+        @logger.info "Error: #{e.inspect}" if e
+      end
+    end
+  end
+end

data/lib/flowcommerce_spree/logging_http_handler.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class LoggingHttpHandler < ::Io::Flow::V0::HttpClient::DefaultHttpHandler
+    attr_reader :http_client, :logger
+
+    def initialize(logger: FlowcommerceSpree.logger)
+      @logger = logger
+    end
+
+    def instance(base_uri, _path)
+      @http_client = LoggingHttpClient.new(base_uri, logger: @logger)
+    end
+  end
+end

data/lib/flowcommerce_spree/refresher.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+# Service class to manage product sync scheduling
+module FlowcommerceSpree
+  class Refresher
+    SYNC_INTERVAL_IN_MINUTES = 60 unless defined?(SYNC_INTERVAL_IN_MINUTES)
+
+    attr_reader :logger
+
+    def initialize(logger: FlowcommerceSpree.logger)
+      @logger = logger
+    end
+
+    def data
+      @data ||= FlowcommerceSpree::Config.product_catalog_upload || {}
+    end
+
+    def duration
+      return '? (unknown)' if !data[:start] || !data[:end] || data[:start] > data[:end]
+
+      (data[:end] - data[:start]) / 60
+    end
+
+    def write
+      yield data
+      FlowcommerceSpree::Config.product_catalog_upload = data
+      @data = nil
+    end
+
+    def schedule_refresh!
+      write do |data|
+        data[:force_refresh] = true
+      end
+    end
+
+    def needs_refresh?
+      return false if in_progress?
+
+      now = Time.zone.now.to_i
+      data[:end] ||= now - 10_000
+
+      # needs refresh if last refresh started more than threshold ago
+      if data[:end] < (now - (60 * SYNC_INTERVAL_IN_MINUTES))
+        logger.info 'Last refresh ended long time ago, needs refresh.'
+        true
+      elsif data[:force_refresh]
+        logger.info 'Force refresh scheduled, refreshing.'
+        true
+      else
+        logger.info format('No need for refresh, ended before %<now>d seconds.', (now - data[:end]))
+        @data = nil
+        false
+      end
+    end
+
+    def in_progress?
+      # This method needs fresh data, that's why not using the memoized `data` method
+      @data = FlowcommerceSpree::Config.product_catalog_upload || {}
+      return false unless data[:in_progress]
+
+      logger.info 'Could not be run, another refresh is still in progress, quitting'
+    end
+
+    # for start just call log_refresh! and end it with has_ended: true statement
+    def log_refresh!(has_ended: false)
+      data.delete(:force_refresh)
+
+      write do |data|
+        if has_ended
+          data[:end] = Time.zone.now.to_i
+          data.delete(:in_progress)
+        else
+          data[:in_progress] = true
+          data[:start]       = Time.zone.now.to_i
+        end
+      end
+    end
+  end
+end

data/lib/flowcommerce_spree/session.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# communicates with flow.io api, easy access to session
+module FlowcommerceSpree
+  class Session
+    attr_accessor :session, :localized, :visitor
+
+    def initialize(ip:, visitor:)
+      ip = '127.0.0.1' if ip == '::1'
+
+      @ip      = ip
+      @visitor = visitor
+    end
+
+    # create session with blank data
+    def create
+      data = { ip: @ip,
+               visit: { id: @visitor,
+                        expires_at: (Time.now + 30.minutes).iso8601 } }
+
+      session_model = ::Io::Flow::V0::Models::SessionForm.new data
+      @session = FlowCommerce.instance(http_handler: LoggingHttpHandler.new)
+                             .sessions.post_organizations_by_organization(ORGANIZATION, session_model)
+    end
+
+    # if we want to manualy switch to specific country or experience
+    def update(data)
+      @session = FlowCommerce.instance.sessions.put_by_session(@session.id,
+                                                               ::Io::Flow::V0::Models::SessionPutForm.new(data))
+    end
+
+    # get local experience or return nil
+    def experience
+      @session.local&.experience
+    end
+
+    def local
+      @session.local
+    end
+
+    def id
+      @session.id
+    end
+
+    def localized?
+      # use flow if we are not in default country
+      return false unless local
+      return false if @localized.class == FalseClass
+
+      local.country.iso_3166_3 != ENV.fetch('FLOW_BASE_COUNTRY').upcase
+    end
+
+    # because we do not get full experience from session, we have to get from exp list
+    def delivered_duty_options
+      return nil unless experience
+
+      return unless (flow_experience = Flow::Experience.get(experience.key))
+
+      Hashie::Mash.new(flow_experience.settings.delivered_duty.to_hash)
+    end
+
+    # if we have more than one choice, we show choice popup
+    def offers_delivered_duty_choice?
+      if (options = delivered_duty_options)
+        options.available.length > 1
+      else
+        false
+      end
+    end
+  end
+end

data/lib/flowcommerce_spree/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  VERSION = '0.0.1'
+end

data/lib/flowcommerce_spree/webhook_service.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  # communicates with flow api, responds to webhook events
+  class WebhookService
+    attr_accessor :errors, :product, :variant
+    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
+      org = @data['organization']
+      if org != ORGANIZATION
+        errors << { message: "Organization name mismatch for #{org}" }
+      else
+        discriminator = @data['discriminator']
+        hook_method = "hook_#{discriminator}"
+        # If hook processing method registered an error, a self.object of WebhookService with this error will be
+        # returned, else an ActiveRecord object will be returned
+        return __send__(hook_method) if respond_to?(hook_method, true)
+
+        errors << { message: "No hook for #{discriminator}" }
+      end
+
+      self
+    end
+
+    private
+
+    def hook_experience_upserted_v2
+      experience = @data['experience']
+      Spree::Zones::Product.find_or_initialize_by(name: experience['key'].titleize).store_flow_io_data(experience)
+    end
+
+    def hook_local_item_upserted
+      if (local_item = @data['local_item'])
+        if (received_sku = local_item.dig('item', 'number'))
+          if (@variant = Spree::Variant.find_by(sku: received_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 [#{received_sku}] not found!" }
+          end
+        else
+          errors << { message: 'SKU param missing' }
+        end
+      else
+        errors << { message: 'Local item param missing' }
+      end
+
+      self
+    end
+
+    def hook_order_upserted_v2
+      errors << { message: 'Order param missing' } unless (received_order = @data['order'])
+
+      if errors.none? && (order_number = received_order['number'])
+        if (order = Spree::Order.find_by(number: order_number))
+          order.flow_data['order'] = received_order.to_hash
+          attrs_to_update = { meta: order.meta.to_json }
+          if order.flow_data['order']['submitted_at'].present?
+            attrs_to_update[:state] = 'complete'
+            attrs_to_update[:completed_at] = Time.zone.now
+          end
+
+          order.update_columns(attrs_to_update)
+          return order
+        else
+          errors << { message: "Order #{order_number} not found" }
+        end
+      else
+        errors << { message: 'Order number param missing' }
+      end
+
+      self
+    end
+
+    # send en email when order is refunded
+    def hook_refund_upserted_v2
+      Spree::OrderMailer.refund_complete_email(@data).deliver
+
+      'Email delivered'
+    end
+  end
+end

data/lib/simple_csv_writer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# simple class to build scv files
+
+# csv = CsvWriter.new
+# csv.add a: 1, b: 'a', c: '"a'
+# csv.add a: ',', b: 'foo, bar'
+# csv.to_s
+
+class SimpleCsvWriter
+  def initialize(delimiter: nil)
+    @data      = []
+    @delimiter = delimiter || "\t"
+  end
+
+  # add hash or list
+  def add(data)
+    list = if data.class == Hash
+             @keys ||= data.keys
+             @keys.map { |key| data[key] }
+           else
+             data
+           end
+
+    @data.push list.map { |el| fmt(el) }.join(@delimiter)
+  end
+
+  def to_s
+    if @keys
+      @keys.map(&:to_s).join(@delimiter) + "\n" +
+        @data.join($RS)
+    else
+      @data.join($RS)
+    end
+  end
+
+  private
+
+  def fmt(item)
+    item = item.to_s.gsub($RS, '\\n').gsub('"', '""')
+
+    item.include?(@delimiter) || item.include?('\\') ? "\"#{item}\"" : item
+  end
+end