flowcommerce-solidus 0.1.11

data/static/app/flow/decorators/spree_order_decorator.rb

@@ -0,0 +1,128 @@
+# added flow specific methods to Spree::Order
+# http://docs.solidus.io/Spree/Order.html
+
+require 'digest/sha1'
+
+Spree::Order.class_eval do
+
+  # we now use Solidus number as Flow number, but I will this here for now
+  def flow_number
+    return self[:flow_number] unless self[:flow_number].blank?
+    return unless id
+    number
+  end
+
+  def flow_order
+    return nil unless flow_data['order']
+    Hashie::Mash.new flow_data['order']
+  end
+
+  # accepts line item, usually called from views
+  def flow_line_item_price line_item, total=false
+    result = unless flow_order
+      Flow.format_default_price(line_item.price * (total ? line_item.quantity : 1))
+    else
+      id = line_item.variant.id.to_s
+
+      lines = flow_order.lines || []
+      item  = lines.select{ |el| el['item_number'] == id }.first
+
+      return Flow.price_not_found unless item
+
+      total ? item['total']['label'] : item['price']['label']
+    end
+
+    # add line item promo
+    # promo_total, adjustment_total
+    result += ' (%s)' % Flow.format_default_price(line_item.promo_total) if line_item.promo_total > 0
+
+    result
+  end
+
+  # prepares array of prices that can be easily renderd in templates
+  def flow_cart_breakdown
+    prices = []
+
+    price_model = Struct.new(:name, :label)
+
+    if flow_order
+      # duty, vat, ...
+      unless flow_order.prices
+        message = Flow::Error.format_message flow_order
+        raise Flow::Error.new(message)
+      end
+
+      flow_order.prices.each do |price|
+        prices.push price_model.new(price['key'].to_s.capitalize , price['label'])
+      end
+    else
+      price_elements = [:item_total, :adjustment_total, :included_tax_total, :additional_tax_total, :tax_total, :shipment_total, :promo_total]
+      price_elements.each do |el|
+        price = send(el)
+        if price > 0
+          label = Flow.format_default_price price
+          prices.push price_model.new(el.to_s.humanize.capitalize, label)
+        end
+      end
+
+      # discount is applied and we allways show it in default currency
+      if adjustment_total != 0
+        formated_discounted_price = Flow.format_default_price adjustment_total
+        prices.push price_model.new('Discount', formated_discounted_price)
+      end
+    end
+
+    # total
+    prices.push price_model.new(Spree.t(:total), flow_total)
+
+    prices
+  end
+
+  # shows localized total, if possible. if not, fall back to Solidus default
+  def flow_total
+    # r flow_order.total.label
+    price = flow_order.total.label if flow_order && flow_order.total
+    price || Flow.format_default_price(total)
+  end
+
+  def flow_experience
+    model = Struct.new(:key)
+    model.new flow_order.experience.key
+  rescue
+    model.new ENV.fetch('FLOW_BASE_COUNTRY')
+  end
+
+  # clear invalid zero amount payments. Solidsus bug?
+  def clear_zero_amount_payments!
+    # class attribute that can be set to true
+    return unless Flow::Order.clear_zero_amount_payments
+
+    payments.where(amount:0, state: ['invalid', 'processing', 'pending']).map(&:destroy)
+  end
+
+  def flow_order_authorized?
+    flow_data && flow_data['authorization'] ? true : false
+  end
+
+  def flow_order_captured?
+    flow_data['capture'] ? true : false
+  end
+
+  # completes order and sets all states to finalized and complete
+  # used when we have confirmed capture from Flow API or PayPal
+  def flow_finalize!
+    finalize! unless state == 'complete'
+    update_column :payment_state, 'paid' if payment_state != 'paid'
+    update_column :state, 'complete'     if state != 'complete'
+  end
+
+  def flow_paymeny_method
+    if flow_data['payment_type'] == 'paypal'
+      'paypal'
+    else
+      'cc' # creait card is default
+    end
+  end
+
+end
+

data/static/app/flow/decorators/spree_product_decorator.rb

@@ -0,0 +1,16 @@
+# added flow specific methods to Spree::Variant
+
+Spree::Product.class_eval do
+
+  # returns price tied to local experience from master variant
+  def flow_local_price(flow_exp)
+    variants.first.flow_local_price(flow_exp)
+  end
+
+  def flow_included?(flow_exp)
+    return true unless flow_exp
+    flow_data['%s.excluded' % flow_exp.key].to_i == 1 ? false : true
+  end
+
+end
+

data/static/app/flow/decorators/spree_user_decorator.rb

@@ -0,0 +1,16 @@
+# added flow specific methods to Spree::User
+# which is for spree / solidus in same time
+# - user object (for admins as well)
+# - customer object
+
+Spree::User.class_eval do
+
+  def flow_number
+    return unless id
+
+    token = ENV.fetch('SECRET_TOKEN')
+    'su-%s' % Digest::SHA1.hexdigest('%d-%s' % [id, token])
+  end
+
+end
+

data/static/app/flow/decorators/spree_variant_decorator.rb

@@ -0,0 +1,124 @@
+# added flow specific methods to Spree::Variant
+# solidus / spree save all the prices inside Variant object
+# we choose to have cache jsonb field named flow_data that will hold all important
+# flow sync data for specific
+
+Spree::Variant.class_eval do
+
+  # after every save we sync product
+  # we generate sh1 checksums to update only when change happend
+  after_save :flow_sync_product
+
+  # clears flow cache from all records
+  def self.flow_truncate
+    all_records = all
+    all_records.each { |o| o.update_column :flow_data, {} }
+    puts 'Truncated %d records' % all_records.length
+  end
+
+  ###
+
+  # syncs product variant with flow
+  def flow_sync_product
+    # initial Solidus seed will fail, so skip unless we have Flow data folder
+    return unless respond_to?(:flow_data)
+
+    flow_item     = flow_api_item
+    flow_item_sh1 = Digest::SHA1.hexdigest flow_api_item.to_json
+
+    # skip if sync not needed
+    return nil if flow_data['last_sync_sh1'] == flow_item_sh1
+
+    response = FlowCommerce.instance.items.put_by_number(Flow.organization, id.to_s, flow_item)
+
+    # after successful put, write cache
+    update_column :flow_data, flow_data.merge('last_sync_sh1'=>flow_item_sh1)
+
+    response
+  end
+
+  ###
+
+  def flow_spree_price
+    '%s %s' % [self.price, self.cost_currency]
+  end
+
+  def flow_prices flow_exp
+    flow_data.dig('exp', flow_exp.key, 'prices') || []
+  end
+
+  # returns price tied to local experience
+  def flow_local_price flow_exp
+    price = flow_prices(flow_exp).first
+
+    if flow_exp && price
+      price['label']
+    else
+      flow_spree_price
+    end
+  end
+
+  # creates object for flow api
+  # TODO: Remove and use the one in rakefile
+  def flow_api_item
+    image_base = 'http://cdn.color-mont.com'
+
+    # add product categories
+    categories = []
+    taxon = product.taxons.first
+    while taxon
+      categories.unshift taxon.name
+      taxon = taxon.parent
+    end
+
+    images = product.images.first ? [
+      { url: image_base + product.display_image.attachment(:large), tags: ['main'] },
+      { url: image_base + product.images.first.attachment.url(:product), tags: ['thumbnail'] }
+    ] : []
+
+    Io::Flow::V0::Models::ItemForm.new(
+      number:      id.to_s,
+      locale:      'en_US',
+      language:    'en',
+      name:        product.name,
+      description: product.description,
+      currency:    cost_currency,
+      price:       price.to_f,
+      images:      images,
+      categories: categories,
+      attributes: {
+        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: product.meta_title.to_s,
+        product_meta_description: product.meta_description.to_s,
+        product_meta_keywords: product.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)
+    experience_key = item.local.experience.key
+    flow_data['exp'] ||= {}
+    flow_data['exp'][experience_key] = {}
+    flow_data['exp'][experience_key]['status'] = item.local.status.value
+    flow_data['exp'][experience_key]['prices'] = item.local.prices.map do |price|
+      price = price.to_hash
+      [:includes, :adjustment].each { |el| price.delete(el) unless price[el] }
+      price
+    end
+
+    update_column :flow_data, flow_data.dup
+  end
+
+end
+

data/static/app/flow/flow.rb

@@ -0,0 +1,67 @@
+# module for communication and customization based on flow api
+# for now all in same class
+
+require 'logger'
+
+module Flow
+  extend self
+
+  def organization() ENV.fetch('FLOW_ORGANIZATION') end
+  def base_country() ENV.fetch('FLOW_BASE_COUNTRY') end
+  def api_key()      ENV.fetch('FLOW_API_KEY') end
+
+  # builds curl command and gets remote data
+  def api action, path, params={}, body=nil
+    body ||= params.delete(:BODY)
+
+    remote_params = URI.encode_www_form params
+    remote_path   = debug_path = path.sub('%o', Flow.organization).sub(':organization', Flow.organization)
+    remote_path  += '?%s' % remote_params unless remote_params.blank?
+
+    curl = ['curl -s']
+    curl.push '-X %s' % action.to_s.upcase
+    curl.push '-u %s:' % api_key
+
+    if body
+      body = body.to_json unless body.is_a?(Array)
+      curl.push '-H "Content-Type: application/json"'
+      curl.push "-d '%s'" % body.gsub(%['], %['"'"']) if body
+    end
+
+    curl.push '"https://api.flow.io%s"' % remote_path
+    command = curl.join(' ')
+
+    puts command if defined?(Rails::Console)
+
+    dir = Rails.root.join('log/api')
+    Dir.mkdir(dir) unless Dir.exist?(dir)
+    debug_file = '%s/%s.bash' % [dir, debug_path.gsub(/[^\w]+/, '_')]
+    File.write debug_file, command + "\n"
+
+    data = JSON.load `#{command}`
+
+    if data.kind_of?(Hash) && data['code'] == 'generic_error'
+      ap data
+      data
+    else
+      data
+    end
+  end
+
+  def log_api_error
+
+  end
+
+  def logger
+    @logger ||= Logger.new('./log/flow.log') # or nil for no logging
+  end
+
+  def price_not_found
+    'n/a'
+  end
+
+  def format_default_price amount
+    '$%.2f' % amount
+  end
+
+end

data/static/app/flow/flow/error.rb

@@ -0,0 +1,46 @@
+# Flow (2017)
+# for flow errors
+
+require 'digest/sha1'
+
+class Flow::Error < StandardError
+
+  # logs error to file for easy discovery and fix
+  def self.log(exception, request)
+    history = exception.backtrace.reject{ |el| el.index('/gems/') }.map{ |el| el.sub(Rails.root.to_s, '') }.join($/)
+
+    msg  = '%s in %s' % [exception.class, request.url]
+    data = [msg, exception.message, history].join("\n\n")
+    key  = Digest::SHA1.hexdigest exception.backtrace.first.split(' ').first
+
+    folder = Rails.root.join('log/exceptions').to_s
+    Dir.mkdir(folder) unless Dir.exists?(folder)
+
+    folder += "/#{exception.class.to_s.tableize.gsub('/','-')}"
+    Dir.mkdir(folder) unless Dir.exists?(folder)
+
+    "#{folder}/#{key}.txt".tap do |path|
+      File.write(path, data)
+    end
+  end
+
+  def self.format_message order, flow_experience=nil
+    message = if order['messages']
+      msg = order['messages'].join(', ')
+
+      if order['numbers']
+        msg += ' (%s)' % Spree::Variant.where(id: order['numbers']).map(&:name).join(', ')
+      end
+
+      msg
+    else
+      'Order not properly localized (sync issue)'
+    end
+
+    sub_info = 'Flow.io'
+    sub_info += ' - %s' % flow_experience.key[0, 15] if flow_experience
+
+    '%s (%s)' % [message, sub_info]
+  end
+
+end

data/static/app/flow/flow/experience.rb

@@ -0,0 +1,51 @@
+# Flow.io (2017)
+# communicates with flow api, easy access
+# to basic shop frontend and backend needs
+
+module Flow::Experience
+  extend self
+
+  def all no_world=nil
+    experiences = get_from_flow
+    no_world ? experiences.select{ |exp| exp.key != 'world' } : experiences
+  end
+
+  def keys
+    all.map{ |el| el.key }
+  end
+
+  def get key
+    all.each do |exp|
+      return exp if exp.key == key
+    end
+    nil
+  end
+
+  def compact
+    all.map { |exp| [exp.country, exp.key, exp.name] }
+  end
+
+  def default
+    Flow::Experience.all.select{ |exp| exp.key == 'united-states-of-america' }.first
+  end
+
+  private
+
+  def get_from_flow
+    return cached_experinces if cache_valid?
+
+    experiences = FlowCommerce.instance.experiences.get(Flow.organization)
+    @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