shopify_dashboard_plus 0.0.7 → 1.0.0

data/lib/shopify_dashboard_plus/helpers.rb

@@ -1,37 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'currency'
+
 module ApplicationHelpers
 
   include Rack::Utils
+  using Currency
+
   alias_method :h, :escape_html
 
-  DESIRED_FIELDS = [
-    "total_price",
-    "created_at",
-    "billing_address",
-    "currency",
-    "line_items",
-    "customer",
-    "referring_site",
-    "discount_codes"
-  ]
+  DESIRED_FIELDS = %w[
+    total_price
+    created_at
+    billing_address
+    currency
+    line_items
+    customer
+    referring_site
+    discount_codes
+  ].freeze
+
+  ## Authentication Helpers
+
+  def authenticated?
+    session[:logged_in]
+  end
+
 
   ## Connection & Setup Helpers
-  
+
   def set_connection(key, pwd, name)
-    shop_url = "https://#{key}:#{pwd}@#{name}.myshopify.com/admin"
-    ShopifyAPI::Base.site = shop_url
+    ShopifyAPI::Base.site = "https://#{key}:#{pwd}@#{name}.myshopify.com/admin"
     shop = ShopifyAPI::Shop.current
+
     $shop_name = name
+    $currency  = shop.money_with_currency_format
+
+    session[:logged_in] = true
     open_connection
-  rescue
+  rescue SocketError, ActiveResource::ResourceNotFound => e
+    puts "Exception: #{e}"
     close_connection
   end
 
   def close_connection
     $connected = false
+    session[:logged_in] = false
   end
 
   def open_connection
     $connected = true
+    session[:logged_in] = true
   end
 
   def connected?
@@ -71,11 +90,11 @@ module ApplicationHelpers
   ## Metrics Helpers
 
   def max_hash_key_exclude_value(unsorted_hash, exclude_value)
-    unsorted_hash.sort_by{ |k, v| v }.map{ |k, v| [k, v] unless k.downcase == exclude_value }.compact.last
+    unsorted_hash.sort_by { |_, v| v }.map { |k, v| [k, v] unless k.downcase == exclude_value }.compact.last
   end
 
   def display_as_currency(value)
-    ShopifyAPI::Shop.current.money_with_currency_format.gsub("{{amount}}", value.to_s)
+    $currency.gsub("{{amount}}", value.to_s)
   rescue
     'N/A'
   end
@@ -92,41 +111,39 @@ module ApplicationHelpers
   end
 
   def get_average_revenue(total_revenue, duration)
-    (total_revenue/duration).round(2)
+    (total_revenue / duration).round(2)
   rescue
     'N/A'
   end
-  
+
   def get_daily_revenues(start_date, end_date, orders)
     # Create hash entry for every day within interval over which to inspect sales
     revenue_per_day = {}
     days = get_date_range(start_date, end_date)
-    (0..days).each{ |day| revenue_per_day[(DateTime.parse(end_date) - day).strftime("%Y-%m-%d")] = 0 }
+    (0..days).each { |day| revenue_per_day[(DateTime.parse(end_date) - day).strftime("%Y-%m-%d")] = 0 }
 
     # Retreive array of ActiveRecord::Collections, each containing orders between the start and end date
-    order_details = orders.map{ |order| [order.created_at, order.total_price.to_f] }
-    
+    order_details = orders.map { |order| [order.created_at, order.total_price.to_f] }
+
     # Filter order details into daily totals and return
     order_details.each do |(date, total)|
       day_index = DateTime.parse(date).strftime('%Y-%m-%d')
       revenue_per_day[day_index] = revenue_per_day[day_index].plus(total)
     end
+
     revenue_per_day
   end
 
   def hash_to_graph_format(sales, merge_results: false)
-    
     # ChartKick requires a strange format to build graphs. For instance, an array of
     #   {:name => <item_name>, :data => [[<customer_id>, <item_price>], [<customer_id>, <item_price>]]}
     # places <customer_id> on the independent (x) axis, and stacks each item (item_name) on the y-axis by price (item_price)
 
-    name_hash = sales.map{ |sale| {:name => sale[:name], :data => []} }.uniq
-    
+    name_hash = sales.map { |sale| { :name => sale[:name], :data => [] } }.uniq
+
     sales.map do |old_hash|
       name_hash.map do |new_hash|
-        if old_hash[:name] == new_hash[:name]
-          new_hash[:data].push(old_hash[:data])
-        end
+        new_hash[:data].push(old_hash[:data]) if old_hash[:name] == new_hash[:name]
       end
     end
 
@@ -146,38 +163,34 @@ module ApplicationHelpers
     name_hash
   end
 
-  # Return order query parameters hash
   def order_parameters_paginate(start_date, end_date, page)
-    {  
-      :created_at_min => start_date + " 0:00", 
-      :created_at_max => end_date + " 23:59:59", 
-      :limit => 250,
-      :page => page,
-      :fields => DESIRED_FIELDS 
+    {
+      :created_at_min => start_date + " 0:00",
+      :created_at_max => end_date + " 23:59:59",
+      :limit  => 250,
+      :page   => page,
+      :fields => DESIRED_FIELDS
     }
   end
 
-
-  # Return array of ActiveRecord::Collections, each containing up to :limit (250) orders
-  # Continue to query next page until less than :limit orders are returned, indicating no next pages with orders matching query
   def get_list_of_orders(start_date, end_date)
+    # Return array of ActiveRecord::Collections, each containing up to :limit (250) orders
+    # Continue to query next page until less than :limit orders are returned, indicating no next pages with orders matching query
 
     # Get first 250 results matching query
     params = order_parameters_paginate(start_date, end_date, 1)
     revenue_metrics = [ShopifyAPI::Order.find(:all, :params => params)]
-    
+
     # If the amount of results equal to the limit (250) were returned, pass the query on to the next page (orders 251 to 500)
     while revenue_metrics.last.length == 250
       params = order_parameters_paginate(start_date, end_date, revenue_metrics.length + 1)
       revenue_metrics << ShopifyAPI::Order.find(:all, :params => params)
     end
 
-    revenue_metrics.flat_map{ |orders| orders.map{ |order| order }}
+    revenue_metrics.flat_map { |orders| orders.map { |order| order } }
   end
-  
 
   def get_detailed_revenue_metrics(start_date, end_date = DateTime.now)
-
     order_list = get_list_of_orders(start_date, end_date)
 
     # Revenue
@@ -185,22 +198,23 @@ module ApplicationHelpers
     duration = get_date_range(start_date, end_date) + 1
     avg_revenue = get_average_revenue(total_revenue, duration)
     daily_revenue = get_daily_revenues(start_date, end_date, order_list)
-    max_daily_revenue = daily_revenue.max_by{ |k,v| v }[1]
-    
+    max_daily_revenue = daily_revenue.max_by { |_, v| v }[1]
+
     # Retrieve Metrics
-    sales_report = ShopifyDashboardPlus::SalesReport.new(order_list).to_h
-    revenue_report = ShopifyDashboardPlus::RevenueReport.new(order_list).to_h
-    traffic_report = ShopifyDashboardPlus::TrafficReport.new(order_list).to_h
+    sales_report     = ShopifyDashboardPlus::SalesReport.new(order_list).to_h
+    revenue_report   = ShopifyDashboardPlus::RevenueReport.new(order_list).to_h
+    traffic_report   = ShopifyDashboardPlus::TrafficReport.new(order_list).to_h
     discounts_report = ShopifyDashboardPlus::DiscountReport.new(order_list).to_h
-    metrics = { 
-      :total_revenue => total_revenue,
-      :average_revenue => avg_revenue,
-      :daily_revenue => daily_revenue,
+    metrics = {
+      :total_revenue     => total_revenue,
+      :average_revenue   => avg_revenue,
+      :daily_revenue     => daily_revenue,
       :max_daily_revenue => max_daily_revenue,
-      :duration => duration
+      :duration          => duration
     }
 
     [sales_report, revenue_report, traffic_report, discounts_report, metrics].inject(&:merge)
   end
 
 end
+

data/lib/shopify_dashboard_plus/report.rb

@@ -1,206 +1,14 @@
+# frozen_string_literal: true
+
 require_relative 'helpers'
 
 module ShopifyDashboardPlus
-
   class Report
     include ApplicationHelpers
 
     def initialize(orders)
-      @orders = orders
-      @line_items = orders.flat_map{ |order| order.line_items.map { |line_item| line_item }}
+      @orders     = orders
+      @line_items = orders.flat_map { |order| order.line_items.map { |line_item| line_item } }
     end
   end
-
-
-  class SalesReport < Report
-    def sales_per_country
-      sales_per_country = Hash.new(0)
-
-      @orders.each do |order|
-        sales_per_country[order.billing_address.country] += 1 if order.attributes['billing_address']
-      end
-      sales_per_country
-    end
-
-    def sales_per_product
-      sales_per_product = Hash.new(0)
-
-      @line_items.each do |item|
-        sales_per_product[item.title] += 1
-      end
-
-      sales_per_product
-    end
-
-    def sales_per_customer
-      customer_sales = []
-      @orders.each do |order|
-        order.line_items.each do |item|
-          customer_name = "#{order.customer.first_name} #{order.customer.last_name} (#{order.customer.email})"
-          customer_sales.push({ :name => item.title,
-                                :data => [customer_name, item.price.to_f]})
-        end
-      end
-      hash_to_graph_format(customer_sales)
-    end
-
-    def sales_per_price_point
-      sales_per_price_point = Hash.new(0)
-
-      @line_items.each do |item|
-        sales_per_price_point[item.price] += 1
-      end
-      sales_per_price_point.sort_by{ |x,y| x.to_f }.to_h rescue {}
-    end
-
-    def number_of_sales
-      @orders.length
-    end
-
-    def currencies_per_sale
-      currencies = Hash.new(0)
-
-      @orders.each do |order|
-        currencies[order.currency] += 1 if order.attributes['currency']
-      end
-      currencies
-    end
-
-    def to_h
-      {
-        :currencies_per_sale => currencies_per_sale,
-        :most_used_currency => currencies_per_sale.sort_by{ |k, v| v }.last,
-        :sales_per_country => sales_per_country,
-        :most_sales_per_country => sales_per_country.sort_by{ |k, v| v }.last,
-        :sales_per_price => sales_per_price_point,
-        :top_selling_price_point => sales_per_price_point.sort_by{ |k, v| v }.last,
-        :sales_per_product => sales_per_product,
-        :top_selling_product => sales_per_product.sort_by{ |k, v| v }.last,
-        :sales_per_customer => sales_per_customer,
-        :number_of_sales => number_of_sales
-      }
-    end
-  end
-
-
-  class RevenueReport < Report
-    def revenue_per_country
-      revenue_per_country = []
-      @orders.each do |order|
-        order.line_items.each do |item|
-          revenue_per_country.push({:name => item.title, 
-                                    :data => [order.billing_address.country, item.price.to_f]})
-        end
-      end
-      hash_to_graph_format(revenue_per_country, merge_results: true)
-    end
-
-    def revenue_per_price_point
-      revenue_per_price_point = Hash.new(0)
-      @line_items.each do |item|
-        revenue_per_price_point[item.price] = revenue_per_price_point[item.price].plus(item.price)
-      end
-      revenue_per_price_point.sort_by{ |x,y| x.to_f }.to_h rescue {}
-    end
-
-    def revenue_per_product
-      revenue_per_product = Hash.new(0.0)
-      @line_items.each do |item|
-        revenue_per_product[item.title] = revenue_per_product[item.title].plus(item.price)
-      end
-      revenue_per_product
-    end
-
-    def to_h
-      {
-        :revenue_per_country => revenue_per_country,
-        :revenue_per_product => revenue_per_product,
-        :top_grossing_product => revenue_per_product.sort_by{ |k, v| v }.last,
-        :revenue_per_price_point => revenue_per_price_point,
-        :top_grossing_price_point => revenue_per_price_point.sort_by{ |k, v| v}.last
-      }
-    end
-  end
-
-
-  class DiscountReport < Report
-
-    def discount_usage
-      discount_value, discount_used = Hash.new(0.0), Hash.new(0)
-
-      @orders.each do |order|
-        if order.attributes['discount_codes']
-          order.discount_codes.each do |discount_code|
-            discount_value[discount_code.code] = discount_value[discount_code.code].plus(discount_code.amount)
-            discount_used[discount_code.code] += 1
-          end
-        end
-      end
-      {
-        :discount_savings => discount_value,
-        :top_discount_savings => discount_value.sort_by{ |k, v| v }.last,
-        :discount_quantity => discount_used,
-        :most_used_discount_code => discount_used.sort_by{ |k, v| v }.last
-      }
-    end
-
-    def to_h
-      discount_usage
-    end
-  end
-
-
-  class TrafficReport < Report
-
-    def number_of_referrals
-      referring_sites, referring_pages = Hash.new(0), Hash.new(0)
-
-      @orders.each do |order|
-        if order.attributes['referring_site'].empty?
-          referring_pages['None'] += 1
-          referring_sites['None'] += 1
-        else
-          host = get_host(order.referring_site)
-          page = strip_protocol(order.referring_site)
-          referring_pages[page] += 1
-          referring_sites[host] += 1
-        end
-      end
-      {
-        :referral_sites => referring_sites.sort().to_h,
-        :top_referral_site => max_hash_key_exclude_value(referring_sites, 'none'),
-        :referral_pages => referring_pages.sort().to_h,
-        :top_referral_page => max_hash_key_exclude_value(referring_pages, 'none')
-      }
-    end
-
-    def traffic_revenue
-      revenue_per_referral_page, revenue_per_referral_site = Hash.new(0.0), Hash.new(0.0)
-
-      @orders.each do |order|
-        order.line_items.each do |item|
-          if order.attributes['referring_site'].empty?
-            revenue_per_referral_page['None'] = revenue_per_referral_page['None'].plus(item.price)
-            revenue_per_referral_site['None'] = revenue_per_referral_site['None'].plus(item.price)
-          else
-            host = get_host(order.referring_site)
-            page = strip_protocol(order.referring_site)
-            revenue_per_referral_site[host] = revenue_per_referral_site[host].plus(item.price)
-            revenue_per_referral_page[page] = revenue_per_referral_page[page].plus(item.price)
-          end
-        end
-      end
-      {
-        :revenue_per_referral_site => revenue_per_referral_site.sort().to_h,
-        :top_referral_site_revenue => max_hash_key_exclude_value(revenue_per_referral_site, 'none'),
-        :revenue_per_referral_page => revenue_per_referral_page.sort().to_h,
-        :top_referral_page_revenue => max_hash_key_exclude_value(revenue_per_referral_page, 'none')
-      }
-    end
-
-    def to_h
-      traffic_revenue.merge(number_of_referrals)
-    end
-  end
-
 end

data/lib/shopify_dashboard_plus/revenue_report.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'currency'
+require_relative 'helpers'
+require_relative 'report'
+
+module ShopifyDashboardPlus
+  class RevenueReport < Report
+    using Currency
+
+    def revenue_per_country
+      revenue_per_country = []
+      @orders.each do |order|
+        order.line_items.each do |item|
+          revenue_per_country.push(
+            :name => item.title,
+            :data => [order.billing_address.country, item.price.to_f]
+          )
+        end
+      end
+      
+      hash_to_graph_format(revenue_per_country, merge_results: true)
+    end
+
+    def revenue_per_price_point
+      revenue_per_price_point = Hash.new(0)
+      @line_items.each do |item|
+        revenue_per_price_point[item.price] = revenue_per_price_point[item.price].plus(item.price)
+      end
+ 
+      revenue_per_price_point.sort_by { |x, _| x.to_f }.to_h
+    rescue
+      {}
+    end
+
+    def revenue_per_product
+      revenue_per_product = Hash.new(0.0)
+      @line_items.each do |item|
+        revenue_per_product[item.title] = revenue_per_product[item.title].plus(item.price)
+      end
+ 
+      revenue_per_product
+    end
+
+    def to_h
+      {
+        :revenue_per_country      => revenue_per_country,
+        :revenue_per_product      => revenue_per_product,
+        :top_grossing_product     => revenue_per_product.sort_by { |_, v| v }.last,
+        :revenue_per_price_point  => revenue_per_price_point,
+        :top_grossing_price_point => revenue_per_price_point.sort_by { |_, v| v }.last
+      }
+    end
+  end
+end