rawbotz 0.1.5 → 0.2.0

data/lib/rawbotz/helpers/order_item_color_helper.rb

@@ -0,0 +1,17 @@
+module Rawbotz
+  module Helpers
+    module OrderItemColorHelper
+      def order_item_class order_item
+        if order_item.ordered? && order_item.all_ordered?
+          "perfect_order"
+        elsif order_item.out_of_stock?
+          "out_of_stock"
+        elsif order_item.not_ordered?
+          "not_ordered"
+        else
+          "partly_available"
+        end
+      end
+    end
+  end
+end

data/lib/rawbotz/helpers/resource_link_helper.rb

@@ -39,6 +39,9 @@ module Rawbotz
           "[no supplier]"
         end
       end
+      def order_link order
+        "<a href=\"/order/#{order.id}\">Order #{order.id} (#{order.supplier.try(:name) || "no supplier"})</a>"
+      end
     end
   end
 end

data/lib/rawbotz/mail_template.rb

@@ -3,27 +3,62 @@ module Rawbotz
     # Substitute certain patterns in template
     def self.consume template, order
       result = ""
-      result = template.gsub(/SUPPLIERNAME/, order[:supplier][:name])
+      result = template.gsub(/SUPPLIERNAME/, order.supplier[:name])
+      result = result.gsub(/PUBLIC_COMMENT/, order.public_comment || "")
 
       lines = result.split("\n")
       subject, lines = lines.partition{|l| l.start_with?("SUBJECT=")}
       product_line = lines.detect{|l| l.start_with?("* ")}
-      order_lines = order[:order_items].map do |oi|
+      order_lines = order.order_items.select{|o|o.num_wished.to_i != 0}.map do |oi|
         next if product_line.nil?
         order_item_line = product_line[2..-1]
-        order_item_line.gsub!(/SUPPLIERSKU/, oi[:local_product][:supplier_sku].to_s)
+        order_item_line.gsub!(/SUPPLIERSKU/, oi.local_product[:supplier_sku].to_s)
         order_item_line.gsub!(/QTY/, oi[:num_wished].to_s)
-        if oi[:local_product][:packsize].to_s != ""
-          order_item_line.gsub!(/NUM_PACKS/, (oi[:num_wished] / oi[:local_product][:packsize].to_f).to_s)
+        if oi.local_product[:packsize].to_s != ""
+          order_item_line.gsub!(/NUM_PACKS/, "%g" % (oi[:num_wished] / oi.local_product[:packsize].to_f))
         else
           order_item_line.gsub!(/NUM_PACKS/, '')
         end
-        order_item_line.gsub!(/PACKSIZE/, oi[:local_product][:packsize].to_s)
-        order_item_line.gsub!(/PRODUCTNAME/, oi[:local_product][:supplier_prod_name] || oi[:local_product][:name].to_s)
+        order_item_line.gsub!(/PACKSIZE/, oi.local_product[:packsize].to_s)
+        if oi.local_product[:supplier_prod_name].to_s != ""
+          order_item_line.gsub!(/PRODUCTNAME/, oi.local_product[:supplier_prod_name])
+        else
+          order_item_line.gsub!(/PRODUCTNAME/, oi.local_product[:name].to_s)
+        end
         order_item_line
+        #SUPPLIERSKU
+        #SUPPLIERPRODUCTNAME
       end
       lines[lines.find_index(product_line)] = order_lines if product_line
       lines.flatten.join("\n")
     end
+
+    def self.extract_subject template, order
+      result = ""
+      result = template.gsub(/SUPPLIERNAME/, order.supplier[:name])
+
+      lines = result.split("\n")
+      subject, lines = lines.partition{|l| l.start_with?("SUBJECT=")}
+      if !subject.empty?
+        subject[0][8..-1]
+      else
+        "Order"
+      end
+    end
+
+    def self.create_mailto_url supplier, order
+      mail_preview = self.consume supplier[:order_template], order
+      subject = self.extract_subject supplier[:order_template], order
+      to_mail = (supplier[:email] || "").split[0]
+      if supplier[:email].to_s == ""
+        cc_mail = ""
+      else
+        cc_mail = supplier[:email].split[1..-1].map{|m| "cc=#{m}"}.join("&")
+      end
+      if cc_mail.to_s != ""
+        cc_mail += "&"
+      end
+      "mailto:#{to_mail}?#{cc_mail}Subject=#{subject}&body=%s" % URI::escape(mail_preview).gsub(/&/,'%26')
+    end
   end
 end

data/lib/rawbotz/models/sales.rb

@@ -0,0 +1,21 @@
+require 'active_model'
+require 'date'
+
+module Rawbotz
+  module Models
+    class Sales
+      include ActiveModel::Model # convenience
+
+      def self.daily_since product_id, num_days=30
+        RawgentoDB::Query.sales_daily_between(product_id,
+          Date.today, Date.today - num_days)
+      end
+
+      def self.monthly_since product_id, num_months=12
+        # Todo create a date num_month month ago (vs x*30)
+        RawgentoDB::Query.sales_monthly_between(product_id,
+          Date.today, Date.today - (num_months * 30)).uniq
+      end
+    end
+  end
+end

data/lib/rawbotz/models/stock.rb

@@ -0,0 +1,25 @@
+require 'active_model'
+
+module Rawbotz
+  module Models
+    class Stock
+      include ActiveModel::Model # convenience
+
+      def self.all_stock
+        stock = {}
+        RawgentoDB::Query.stock.each {|s| stock[s.product_id] = s.qty}
+        stock
+      end
+
+      # Returns a map of product_id to RawgentoDB::ProductQty .
+      def self.stock_for product_ids
+        stock = {}
+        # Find ruby idiomatic way to do that (probably map{}.to_h)
+        RawgentoDB::Query.stock_for(product_ids).each do |s|
+          stock[s.product_id] = s.qty
+        end
+        stock
+      end
+    end
+  end
+end

data/lib/rawbotz/models/stock_product.rb

@@ -0,0 +1,146 @@
+require 'active_model'
+
+module Rawbotz
+  module Models
+    class UnsupportedNumberOfDaysError < StandardError
+    end
+
+    class StockProduct
+      include ActiveModel::Model # convenience
+
+      attr_accessor :product, :current_stock,
+        :sales_last_30, :sales_last_60, :sales_last_90, :sales_last_365,
+        :num_days_first_sale, :mem_corrected_sales
+
+      delegate :name, to: :product
+
+      def expected_stock_lifetime
+        if @current_stock.to_i == 0 || sales_per_day.nil? || sales_per_day == 0.0
+          return 0.0
+        end
+        @current_stock / sales_per_day
+      end
+
+      def real_sales num_days
+        if num_days == 30
+          @sales_last_30
+        elsif num_days == 60
+          @sales_last_60
+        elsif num_days == 90
+          @sales_last_90
+        elsif num_days == 365
+          @sales_last_365
+        else
+          raise UnsupportedNumberOfDaysError
+        end
+      end
+
+      def corrected_sales num_days, per_days: num_days
+        factor = num_days.to_f / per_days
+        sales = nil
+        if num_days == 30
+          sales = corrected_sales_last_30
+        elsif num_days == 60
+          sales = corrected_sales_last_60
+        elsif num_days == 90
+          sales = corrected_sales_last_90
+        elsif num_days == 365
+          sales = corrected_sales_last_365
+        else
+          raise UnsupportedNumberOfDaysError
+        end
+        return nil if sales.nil?
+        sales / factor
+      end
+
+      # We should also extrapolate (out of-) stock days!
+
+      def corrected_sales_last_30
+        @mem_corrected_sales ||= {}
+        @mem_corrected_sales[30] ||= calculate_corrected_sales(30)
+      end
+
+      def corrected_sales_last_60
+        @mem_corrected_sales ||= {}
+        @mem_corrected_sales[60] ||= calculate_corrected_sales(60)
+      end
+
+      def corrected_sales_last_90
+        @mem_corrected_sales ||= {}
+        @mem_corrected_sales[90] ||= calculate_corrected_sales(90)
+      end
+
+      def corrected_sales_last_365
+        @mem_corrected_sales ||= {}
+        @mem_corrected_sales[365] ||= calculate_corrected_sales(365)
+      end
+
+      def days_since_first_stock_date
+        #@mem_days_since_first_stock_date ||=
+        return 0 if !@product.first_stock_record.present?
+        first_stock_date = @product.first_stock_record.created_at.to_date
+        Date.today - first_stock_date
+      end
+
+      def out_of_stock_days num_days
+        @product.out_of_stock_days_since(Date.today - num_days)
+      end
+
+      def sales_per_day
+        case sales_per_day_base
+        when 365
+          @sales_last_365 / days_in_stock(365).to_f
+        when 90
+          @sales_last_90 / days_in_stock(90).to_f
+        when 60
+          @sales_last_60 / days_in_stock(60).to_f
+        when 30
+          return nil if @sales_last_30.nil?
+          return nil if days_in_stock(30).to_i == 0
+          @sales_last_30 / days_in_stock(30).to_f
+        else
+          raise UnsupportedNumberOfDaysError
+        end
+      end
+
+      def sales_per_day_base
+        product_days_first_stock = @product.days_since_first_stock
+        #first saleproduct_days_first_stock = @product.days_since_first_stock
+        if @sales_last_365.present? && product_days_first_stock >= 365 && num_days_first_sale >= 365 && days_in_stock(365) != 0
+          return 365
+        elsif @sales_last_90.present? && product_days_first_stock >= 90 && num_days_first_sale >= 90 && days_in_stock(90) != 0
+          return 90
+        elsif @sales_last_60.present? && product_days_first_stock >= 60 && num_days_first_sale >= 60 && days_in_stock(60) != 0
+          return 60
+        #elsif @sales_last_30.present?
+        else
+          # today - last sale ?
+          return 30
+        end
+      end
+
+      private
+
+      # For easier memoization
+      def calculate_corrected_sales num_days
+        return nil if days_in_stock(num_days).to_i == 0
+        return nil if real_sales(num_days).nil?
+        if days_in_stock(num_days).to_i != 0
+          real_sales(num_days) * factor_days_in_stock(num_days)
+        else
+          0
+        end
+      end
+
+      # From the last num_days, how many days was the product in stock?
+      def days_in_stock num_days
+        num_days - out_of_stock_days(num_days)
+      end
+
+      # Factor to extrapolate sales, e.g. 1/2 of time out of stock makes factor 2.0
+      def factor_days_in_stock num_days
+        num_days.to_f / days_in_stock(num_days)
+      end
+    end
+  end
+end

data/lib/rawbotz/models/stock_product_factory.rb

@@ -0,0 +1,64 @@
+module Rawbotz
+  module Models
+    module StockProductFactory
+      include RawgentoModels
+      include RawgentoDB
+
+      def self.create_single product
+        product_id = product.product_id
+        sales_30  = Query.num_sales_since(Date.today - 30,  product_id)
+        sales_60  = Query.num_sales_since(Date.today - 60,  product_id)
+        sales_90  = Query.num_sales_since(Date.today - 90,  product_id)
+        sales_365 = Query.num_sales_since(Date.today - 365, product_id)
+
+        beginning_of_time = StockItem.order(created_at: :asc).pluck(:created_at).first.to_date
+
+        sales       = Query.num_sales_since(beginning_of_time, product_id)
+        first_sales = Query.first_sales(product_id)
+        # Default to today instead of nil date
+        first_sales.default = Date.today
+
+        # stock product has trouble when empty values ...
+        stock = Query.stock.find {|s| s.product_id = product_id}.qty
+        StockProduct.new(product: LocalProduct.unscoped.find_by(product_id: product_id),
+                         current_stock: stock[product_id],
+                         sales_last_30: sales_30[product_id]&.qty ,
+                         sales_last_60: sales_60[product_id]&.qty ,
+                         sales_last_90: sales_90[product_id]&.qty ,
+                         sales_last_365: sales_365[product_id]&.qty ,
+                         num_days_first_sale: Date.today - first_sales[product_id].to_date
+                        )
+
+      end
+
+      def self.create suppliers
+        product_ids = LocalProduct.unscoped.where(supplier_id: suppliers.map(&:id), active: true).pluck(:product_id)
+
+        sales_30  = Query.num_sales_since(Date.today - 30,  product_ids)
+        sales_60  = Query.num_sales_since(Date.today - 60,  product_ids)
+        sales_90  = Query.num_sales_since(Date.today - 90,  product_ids)
+        sales_365 = Query.num_sales_since(Date.today - 365, product_ids)
+
+        beginning_of_time = StockItem.order(created_at: :asc).first.created_at.to_date
+
+        sales       = Query.num_sales_since(beginning_of_time, product_ids)
+        first_sales = Query.first_sales(product_ids)
+        # Default to today instead of nil date
+        first_sales.default = Date.today
+        stock = {}
+
+        Query.stock.each {|s| stock[s.product_id] = s.qty}
+        product_ids.map do |product_id|
+          StockProduct.new(product: LocalProduct.unscoped.find_by(product_id: product_id),
+                           current_stock: stock[product_id],
+                           sales_last_30: sales_30[product_id]&.qty,
+                           sales_last_60: sales_60[product_id]&.qty,
+                           sales_last_90: sales_90[product_id]&.qty,
+                           sales_last_365: sales_365[product_id]&.qty,
+                           num_days_first_sale: Date.today - first_sales[product_id].to_date
+                          )
+        end
+      end
+    end
+  end
+end

data/lib/rawbotz/processors/order_linker.rb

@@ -0,0 +1,50 @@
+module Rawbotz
+  class OrderLinker
+    include RawgentoModels
+
+    OrderItemLine = Struct.new(:remote_product_name,
+                               :qty_ordered,
+                               :qty_refunded)
+    OrderItemRecord = Struct.new(:order_item,
+                                 :qty_ordered,
+                                 :qty_refunded)
+
+    attr_accessor :order, :orphans, :refunds
+
+    def initialize(order)
+      @order = order
+    end
+
+    # Links a local rawbotz order to a remote (magento) order.
+    #
+    # Set @orphans (remote order items that do not directly match,
+    # @refunds (maps not only refunded order_item to OrderItemLine)
+    # and @matched_order_items
+    def link!
+      # My, thats a hairy regex
+      shop_order_id = @order.remote_order_link[/\d+/]
+      @remote_order_lines = Rawbotz.mech.products_from_order(shop_order_id).map do |line|
+        OrderItemLine.new(line[0],
+                          line[2],
+                          line[3])
+      end
+      matches, orphans = @remote_order_lines.partition{|line| !order_item(line).nil?}
+      @matched_order_items = matches.map{|line| order_item line}
+      @orphans = orphans
+      @refunds = @matched_order_items.map do |oi|
+        [oi, @remote_order_lines.find{|l| l.remote_product_name == oi.local_product.remote_product.name}]
+      end.to_h
+    end
+
+    private
+    # Get the order item of the order, or nil.
+    def order_item order_item_line
+      remote_product = RemoteProduct.find_by name: order_item_line.remote_product_name
+      return nil if remote_product.blank?
+      return nil if remote_product.local_product.blank?
+
+      @order.order_items.processible.where(local_product: remote_product.local_product).first
+    end
+  end
+end
+

data/lib/rawbotz/{order_processor.rb → processors/order_processor.rb}

@@ -1,8 +1,12 @@
+require 'date'
+
 module Rawbotz
   class OrderProcessor
     def initialize(order, logger=Logger.new("/dev/null"))
       @order = order
       @logger = logger
+      @form_token = YAML::load_file(
+        Rawbotz::conf_file_path)["remote_shop"]["form_token"]
     end
 
     # Yield items, if block given
@@ -15,8 +19,10 @@ module Rawbotz
           log_product_handling item
 
           begin
-            ordered_qty = mech.add_to_cart! item.remote_product_id, item.num_wished
-          rescue
+            ordered_qty = mech.add_to_cart! item.remote_product_id, item.num_wished, @form_token
+          rescue Exception => e
+            STDERR.puts e.message.to_s
+            STDERR.puts e.backtrace
             ordered_qty = nil
             item.update(state: "error")
           end
@@ -31,11 +37,12 @@ module Rawbotz
           @logger.warn(item.attributes)
         end
       end
+      @order.update(ordered_at: DateTime.now)
     end
 
     # Returns diff -> perfect: [], ...
     def check_against_cart
-      diff = {perfect: [], under_avail: [], extra: [], modified: [], miss: []}.to_h
+      diff = {perfect: [], under_avail: [], extra: [], modified: [], miss: [], error: []}.to_h
       # have logger
       mech = Rawbotz::new_mech
       mech.login
@@ -65,6 +72,10 @@ module Rawbotz
         diff[:extra] << [name, qty]
       end
 
+      @order.order_items.where(state: "error").find_each do |item|
+        diff[:error] << [item.local_product.name]
+      end
+
       diff
     end