flowcommerce_spree 0.0.1

data/app/mailers/spree/spree_order_mailer_decorator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Spree
+  OrderMailer.class_eval do
+    # default from: ApplicationMailer::DEFAULT_FROM
+
+    def refund_complete_email(web_hook_event)
+      auth_id = web_hook_event.dig('refund', 'authorization', 'key')
+
+      raise Flow::Error, 'authorization key not found in WebHookEvent [refund_capture_upserted_v2]' unless auth_id
+
+      authorization = FlowcommerceSpree.client.authorizations.get_by_key FlowcommerceSpree::ORGANIZATION, auth_id
+
+      refund_requested = web_hook_event['refund']['requested']
+      @mail_to = authorization.customer.email
+      @full_name = "#{authorization.customer.name.first} #{authorization.customer.name.last}"
+      @amount = "#{refund_requested['amount']} #{refund_requested['currency']}"
+      @number = authorization.order.number
+      @order = Spree::Order.find_by number: @number
+
+      mail(to: @mail_to, subject: "We refunded your order for ammount #{@amount}")
+    end
+  end
+end

data/app/models/flowcommerce_spree/settings.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class Settings < Spree::Preferences::Configuration
+    preference :additional_attributes, :hash, default: {}
+    preference :product_catalog_upload, :hash, default: {}
+  end
+end

data/app/models/spree/credit_card_decorator.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Spree
+  CreditCard.class_eval do
+    serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
+
+    store_accessor :meta, :flow_data
+  end
+end

data/app/models/spree/flow_io_product_decorator.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Flow specific methods for Spree::Product
+module Spree
+  module FlowIoProductDecorator
+    def self.prepended(base)
+      base.serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
+
+      base.store_accessor :meta, :flow_data, :zone_ids
+    end
+
+    def price_in_zone(currency, product_zone)
+      flow_experience_key = product_zone&.flow_data&.[]('key')
+      return flow_local_price(flow_experience_key) if flow_experience_key.present?
+
+      price_in(currency)
+    end
+
+    # returns price bound to local experience from master variant
+    def flow_local_price(flow_exp)
+      master.flow_local_price(flow_exp) || Spree::Price.new(variant_id: id, currency: 'USD', amount: 0)
+    end
+
+    def flow_included?(flow_exp)
+      return true unless flow_exp
+
+      flow_data["#{flow_exp.key}.excluded"].to_i != 1
+    end
+
+    def price_range(product_zone)
+      prices = {}
+      master_prices.each do |p|
+        currency = p.currency
+        min = nil
+        max = nil
+
+        if variants.any?
+          variants.each do |v|
+            price = v.price_in(currency)
+            next if price.nil? || price.amount.nil?
+
+            min = price if min.nil? || min.amount > price.amount
+            max = price if max.nil? || max.amount < price.amount
+          end
+        else
+          min = max = master.price_in(currency)
+        end
+
+        rmin = min&.amount&.to_s(:rounded, precision: 0) || 0
+        rmax = max&.amount&.to_s(:rounded, precision: 0) || 0
+
+        prices[currency] = rmin == rmax ? { amount: rmin } : { min: rmin, max: rmax }
+      end
+
+      add_flow_price_range(prices, product_zone)
+    end
+
+    def add_flow_price_range(prices, product_zone)
+      flow_experience_key = product_zone&.flow_data&.[]('key')
+      return prices if flow_experience_key.blank?
+
+      master_price = master.flow_local_price(flow_experience_key)
+      currency = product_zone.flow_io_experience_currency
+      min = nil
+      max = nil
+
+      if variants.any?
+        variants.each do |v|
+          price = v.flow_local_price(flow_experience_key)
+          next if price.amount.nil? || price.currency != currency
+
+          min = price if min.nil? || min.amount > price.amount
+          max = price if max.nil? || max.amount < price.amount
+        end
+      end
+
+      if master_price.currency == currency
+        min ||= master_price
+        max ||= master_price
+      end
+
+      rmin = min&.amount&.to_s(:rounded, precision: 0) || 0
+      rmax = max&.amount&.to_s(:rounded, precision: 0) || 0
+
+      prices[currency] = rmin == rmax ? { amount: rmin } : { min: rmin, max: rmax }
+      prices
+    end
+
+    Spree::Product.prepend(self) if Spree::Product.included_modules.exclude?(self)
+  end
+end

data/app/models/spree/flow_io_variant_decorator.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+# Flow specific methods for Spree::Variant
+# Spree save all the prices inside Variant object. We choose to have a cache jsonb field named flow_data that will
+# hold all important Flow sync data for specific experiences.
+module Spree
+  module FlowIoVariantDecorator
+    def self.prepended(base)
+      base.serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
+
+      base.store_accessor :meta, :flow_data
+
+      # after every save we sync product we generate sh1 checksums to update only when change happend
+      base.after_save :sync_product_to_flow
+    end
+
+    def experiences
+      flow_data&.[]('exp')
+    end
+
+    def add_flow_io_experience_data(exp, value)
+      raise ArgumentError, 'Value should be a hash' unless value.is_a?(Hash)
+
+      self.flow_data = flow_data || {}
+      self.flow_data['exp'] ||= {}
+      self.flow_data['exp'][exp] = value
+    end
+
+    # clears flow_data from the records
+    def truncate_flow_data
+      flow_data&.[]('exp')&.keys&.each do |exp_key|
+        break unless (product = self.product)
+
+        remove_experience_from_product(exp_key, product)
+      end
+
+      meta.delete(:flow_data)
+      update_column(:meta, meta.to_json)
+    end
+
+    def remove_experience_from_product(exp_key, product)
+      return unless (zone = Spree::Zones::Product.find_by(name: exp_key.titleize))
+
+      zone_ids = product.zone_ids || []
+      zone_id_string = zone.id.to_s
+      return unless zone_ids.include?(zone_id_string)
+
+      product.zone_ids = zone_ids - [zone_id_string]
+      product.update_columns(meta: product.meta.to_json)
+    end
+
+    # upload product variant to Flow's Product Catalog
+    def sync_product_to_flow
+      # initial Spree seed will fail, so skip unless we have Flow data field
+      return unless respond_to?(:flow_data)
+
+      return if FlowcommerceSpree::API_KEY.blank? || FlowcommerceSpree::API_KEY == 'test_key'
+
+      return { error: 'Price is 0' } if price == 0
+
+      additional_attrs = {}
+      attr_name = nil
+      export_required = false
+      FlowcommerceSpree::Config.additional_attributes[self.class.name.tableize.tr('/', '_').to_sym]&.each do |attr_item|
+        attr_name = attr_item[0]
+        # Flow.io could require a different attribute name, as in case of Fulfil's :customs_description - it has the
+        # export_name `:materials` for flow.io. That's why 1st we're checking if an export_name is defined for the
+        # attribute.
+        attr_flowcommerce_name = attr_item[1][:export_name] || attr_name
+        export_required = attr_item[1][:export] == :required
+        attr_value = __send__(attr_name)
+        break if export_required && attr_value.blank?
+
+        additional_attrs[attr_flowcommerce_name] = attr_value if attr_value
+      end
+
+      if export_required && additional_attrs[attr_value].blank?
+        return { error: "Variant with sku = #{sku} has no #{attr_name}" }
+      end
+
+      flow_item     = to_flowcommerce_item(additional_attrs)
+      flow_item_sh1 = Digest::SHA1.hexdigest(flow_item.to_json)
+
+      # skip if sync not needed
+      return nil if flow_data&.[](:last_sync_sh1) == flow_item_sh1
+
+      response = FlowcommerceSpree.client.items.put_by_number(FlowcommerceSpree::ORGANIZATION, sku, flow_item)
+      self.flow_data ||= {}
+      self.flow_data[:last_sync_sh1] = flow_item_sh1
+
+      # after successful put, write cache
+      update_column(:meta, meta.to_json)
+
+      response
+    rescue Net::OpenTimeout => e
+      { error: e.message }
+    end
+
+    def flow_prices(flow_exp)
+      flow_data&.dig(:exp, flow_exp, :prices) || []
+    end
+
+    # returns price bound to local experience
+    def flow_local_price(flow_exp)
+      price_object = flow_prices(flow_exp)&.first
+      amount = price_object&.[](:amount) || price
+      currency = price_object&.[](:currency) || cost_currency
+      Spree::Price.new(variant_id: id, currency: currency, amount: amount)
+    end
+
+    def price_in_zone(currency, product_zone)
+      flow_experience_key = product_zone&.flow_data&.[]('key')
+      return flow_local_price(flow_experience_key) if flow_experience_key.present?
+
+      price_in(currency)
+    end
+
+    def all_prices_in_zone(product_zone)
+      all_prices = prices.map { |price| { currency: price.currency, amount: (price.amount&.round || 0).to_s } }
+
+      flow_experience_key = product_zone&.flow_data&.[]('key')
+      return all_prices if flow_experience_key.blank?
+
+      flow_price = flow_local_price(flow_experience_key)
+      all_prices << { currency: flow_price.currency, amount: (flow_price.amount&.round || 0).to_s }
+      all_prices
+    end
+
+    # creates object for flow api
+    def to_flowcommerce_item(additional_attrs)
+      # add product categories
+      categories = []
+      taxon = product.taxons.first
+      current_taxon = taxon
+      while current_taxon
+        categories.unshift current_taxon.name
+        current_taxon = current_taxon.parent
+      end
+
+      images = if (image = product.images.first || product.variant_images.first)
+                 asset_host_scheme = ENV.fetch('ASSET_HOST_PROTOCOL', 'https')
+                 asset_host = ENV.fetch('ASSET_HOST', 'staging.mejuri.com')
+                 large_image_uri = URI(image.attachment(:large))
+                 product_image_uri = URI(image.attachment.url(:product))
+                 large_image_uri.scheme ||= asset_host_scheme
+                 product_image_uri.scheme ||= asset_host_scheme
+                 large_image_uri.host ||= asset_host
+                 product_image_uri.host ||= asset_host
+
+                 [{ url: large_image_uri.to_s, tags: ['checkout'] },
+                  { url: product_image_uri.to_s, tags: ['thumbnail'] }]
+               else
+                 []
+               end
+
+      Io::Flow::V0::Models::ItemForm.new(
+        number: sku,
+        locale: 'en_US',
+        language: 'en',
+        name: product.name,
+        description: product.description,
+        currency: cost_currency,
+        price: price.to_f,
+        images: images,
+        categories: categories,
+        attributes: common_attrs(taxon).merge!(additional_attrs)
+      )
+    end
+
+    def common_attrs(taxon)
+      {
+        weight: weight.to_s,
+        height: height.to_s,
+        width: width.to_s,
+        depth: depth.to_s,
+        is_master: is_master ? 'true' : 'false',
+        product_id: product_id.to_s,
+        tax_category: product.tax_category_id.to_s,
+        product_description: product.description,
+        product_shipping_category: product.shipping_category_id ? shipping_category.name : nil,
+        product_meta_title: taxon&.meta_title.to_s,
+        product_meta_description: taxon&.meta_description.to_s,
+        product_meta_keywords: taxon&.meta_keywords.to_s,
+        product_slug: product.slug
+      }.select { |_k, v| v.present? }
+    end
+
+    # gets flow catalog item, and imports it
+    # called from flow:sync_localized_items rake task
+    def flow_import_item(item_hash, experience_key: nil)
+      # If experience not specified, get it from the local hash of imported variant
+      experience_key ||= item_hash.dig(:local, :experience, :key)
+      current_experience_meta = item_hash.delete(:local)
+
+      # Do not repeatedly store Experience data - this is stored in Spree::Zones::Product
+      current_experience_meta.delete(:experience)
+      add_flow_io_experience_data(experience_key, current_experience_meta)
+      self.flow_data.merge!(item_hash)
+
+      update_column(:meta, meta.to_json)
+    end
+
+    Spree::Variant.prepend(self) if Spree::Variant.included_modules.exclude?(self)
+  end
+end

data/app/models/spree/gateway/spree_flow_gateway.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# Flow.io (2017)
+# adapter for Spree that talks to activemerchant_flow
+module Spree
+  class Gateway
+    class Flow < Gateway
+      def provider_class
+        self.class
+      end
+
+      def actions
+        %w[capture authorize purchase refund void]
+      end
+
+      # if user wants to force auto capture
+      def auto_capture?
+        false
+      end
+
+      def payment_profiles_supported?
+        true
+      end
+
+      def method_type
+        'gateway'
+      end
+
+      def preferences
+        {}
+      end
+
+      def supports?(source)
+        # flow supports credit cards
+        source.class == Spree::CreditCard
+      end
+
+      def authorize(_amount, _payment_method, options = {})
+        order = load_order options
+        order.cc_authorization
+      end
+
+      def capture(_amount, _payment_method, options = {})
+        order = load_order options
+        order.cc_capture
+      end
+
+      def purchase(_amount, _payment_method, options = {})
+        order = load_order options
+        flow_auth = order.cc_authorization
+
+        if flow_auth.success?
+          order.cc_capture
+        else
+          flow_auth
+        end
+      end
+
+      def refund(_money, _authorization_key, options = {})
+        order = load_order options
+        order.cc_refund
+      end
+
+      def void(money, authorization_key, options = {})
+        # binding.pry
+      end
+
+      def create_profile(payment)
+        # binding.pry
+
+        # payment.order.state
+        @credit_card = payment.source
+
+        profile_ensure_payment_method_is_present!
+        create_flow_cc_profile!
+      end
+
+      private
+
+      # hard inject Flow as payment method unless defined
+      def profile_ensure_payment_method_is_present!
+        return if @credit_card.payment_method_id
+
+        flow_payment = Spree::PaymentMethod.where(active: true, type: 'Spree::Gateway::Flow').first
+        @credit_card.payment_method_id = flow_payment.id if flow_payment
+      end
+
+      # create payment profile with Flow and tokenize Credit Card
+      def create_flow_cc_profile!
+        return if @credit_card.gateway_customer_profile_id
+        return unless @credit_card.verification_value
+
+        # build credit card hash
+        data = {}
+        data[:number]           = @credit_card.number
+        data[:name]             = @credit_card.name
+        data[:cvv]              = @credit_card.verification_value
+        data[:expiration_year]  = @credit_card.year.to_i
+        data[:expiration_month] = @credit_card.month.to_i
+
+        # tokenize with Flow
+        # rescue Io::Flow::V0::HttpClient::ServerError
+        card_form = ::Io::Flow::V0::Models::CardForm.new(data)
+        result    = FlowcommerceSpree.client.cards.post(::FlowcommerceSpree::ORGANIZATION, card_form)
+
+        @credit_card.update_column :gateway_customer_profile_id, result.token
+      end
+
+      def load_order(options)
+        order_number = options[:order_id].split('-').first
+        spree_order  = Spree::Order.find_by number: order_number
+        ::Flow::SimpleGateway.new spree_order
+      end
+    end
+  end
+end