solidus_admin_insights 2.1.0

data/app/reports/spree/report/date_slicer.rb

@@ -0,0 +1,61 @@
+module Spree::Report::DateSlicer
+  def self.slice_into(start_date, end_date, time_scale, klass)
+    case time_scale
+    when :hourly
+      slice_hours_into(start_date, end_date, klass)
+    when :daily
+      slice_days_into(start_date, end_date, klass)
+    when :monthly
+      slice_months_into(start_date, end_date, klass)
+    when :yearly
+      slice_years_into(start_date, end_date, klass)
+    end
+  end
+
+  def self.slice_hours_into(start_date, end_date, klass)
+    current_date = start_date
+    slices = []
+    while current_date < end_date
+      slices << (0..23).collect do |hour|
+        obj = klass.new
+        obj.date = current_date
+        obj.hour = hour
+        obj
+      end
+      current_date = current_date.next_day
+    end
+    slices.flatten
+  end
+
+  def self.slice_days_into(start_date, end_date, klass)
+    current_date = start_date
+    slices = []
+    while current_date < end_date
+      obj = klass.new
+      obj.date = current_date
+      slices << obj
+      current_date = current_date.next_day
+    end
+    slices
+  end
+
+  def self.slice_months_into(start_date, end_date, klass)
+    current_date = start_date
+    slices = []
+    while current_date < end_date
+      obj = klass.new
+      obj.date = current_date
+      slices << obj
+      current_date = current_date.end_of_month.next_day
+    end
+    slices
+  end
+
+  def self.slice_years_into(start_date, end_date, klass)
+    (start_date.year..end_date.year).collect do |year|
+      obj = klass.new
+      obj.date = Date.new(year).end_of_year
+      obj
+    end
+  end
+end

data/app/reports/spree/report/observation.rb

@@ -0,0 +1,49 @@
+class Spree::Report::Observation
+
+  def initialize
+    set_defaults
+  end
+
+  class << self
+    def observation_fields(records)
+      case records
+      when Hash
+        build_from_hash(records)
+      else
+        build_from_list(records)
+      end
+    end
+
+    def build_from_hash(records)
+      build_from_list(records.keys)
+
+      define_method :set_defaults do
+        records.keys.each do |key|
+          self.send("#{ key }=", records[key])
+        end
+      end
+    end
+
+    def build_from_list(records)
+      attr_accessor *records
+
+      define_method :populate do |result|
+        records.each do |record|
+          record_name = record.to_s
+          self.send("#{ record }=", result[record_name]) if result[record_name]
+        end
+      end
+
+      define_method :set_defaults do
+      end
+
+      define_method :observations_to_h do
+        records.inject({}) { |acc, record| acc[record] = self.send(record); acc }
+      end
+    end
+  end
+
+  def to_h
+    observations_to_h
+  end
+end

data/app/reports/spree/report/query_fragments.rb

@@ -0,0 +1,45 @@
+module Spree::Report::QueryFragments
+  def self.from_subquery(subquery, as: 'results')
+    Arel::SelectManager.new(Arel.sql("(#{subquery.to_sql}) as #{ as }"))
+  end
+
+  def self.from_join(subquery1, subquery2, join_expr)
+    Arel::SelectManager.new(Arel.sql("((#{ subquery1.to_sql }) as q1 JOIN (#{ subquery2.to_sql }) as q2 ON #{ join_expr })"))
+  end
+
+  def self.from_union(subquery1, subquery2, as: 'results')
+    Arel::SelectManager.new(Arel.sql("((#{ subquery1.to_sql }) UNION (#{ subquery2.to_sql })) as #{ as }"))
+  end
+
+  def self.year(column, as='year')
+    extract_from_date(:year, column, as)
+  end
+
+  def self.month(column, as='month')
+    extract_from_date(:month, column, as)
+  end
+
+  def self.week(column, as='week')
+    extract_from_date(:week, column, as)
+  end
+
+  def self.day(column, as='day')
+    extract_from_date(:day, column, as)
+  end
+
+  def self.hour(column, as='hour')
+    extract_from_date(:hour, column, as)
+  end
+
+  def self.extract_from_date(part, column, as)
+    "EXTRACT(#{ part } from #{ column }) AS #{ as }"
+  end
+
+  def self.if_null(val, default_val)
+    Arel::Nodes::NamedFunction.new('COALESCE', [val, default_val])
+  end
+
+  def self.sum(node)
+    Arel::Nodes::NamedFunction.new('SUM', [node])
+  end
+end

data/app/reports/spree/report/query_time_scale.rb

@@ -0,0 +1,19 @@
+module Spree::Report::QueryTimeScale
+  def self.select(time_scale, time_scale_on)
+    db_col_name = time_scale_on.present? ? "#{ time_scale_on }.created_at" : "created_at"
+    time_scale_columns(time_scale).collect { |time_scale_column| ::Spree::Report::QueryFragments.public_send(time_scale_column, db_col_name) }
+  end
+
+  def self.time_scale_columns(time_scale)
+    case time_scale
+    when :hourly
+      [:day, :hour]
+    when :daily
+      [:month, :day]
+    when :monthly
+      [:year, :month]
+    when :yearly
+      [:year]
+    end
+  end
+end

data/app/reports/spree/report/result.rb

@@ -0,0 +1,100 @@
+module Spree
+  class Report
+    class Result
+      attr_accessor :start_date, :end_date, :time_scale, :report
+      attr_reader   :observations
+
+      def initialize
+        yield self
+        build_report_observations
+      end
+
+      def build_report_observations
+        query_results
+        populate_observations
+      end
+
+      def query_results
+        @results = report.get_results
+      end
+
+      def populate_observations
+        @observations = @results.collect do |result|
+          _observation = self.class::Observation.new
+          _observation.populate(result)
+          _observation
+        end
+      end
+
+
+      def to_h
+        {
+          deeplink:            report.deeplink_properties,
+          total_pages:         report.total_pages,
+          per_page:            report.records_per_page,
+          pagination_required: report.pagination_required?,
+          headers:             headers,
+          search_attributes:   search_attributes,
+          stats:               observations.collect(&:to_h),
+          chart_json:          chart_json
+        }
+      end
+
+      def chart_json
+        {
+          chart: false,
+          charts: []
+        }
+      end
+
+      def self.charts(*report_charts)
+        define_method :chart_json do
+          {
+            chart: true,
+            charts: report_charts.collect { |report_chart| report_chart.new(self).to_h }.flatten
+          }
+        end
+      end
+
+      def search_attributes
+        report.class::SEARCH_ATTRIBUTES.transform_values { |value| value.to_s.humanize }
+      end
+
+      def total_pages # O indexed
+        if report.pagination_required?
+          total_pages = report.total_records / report.records_per_page
+          if report.total_records % report.records_per_page == 0
+            total_pages -= 1
+          end
+          total_pages
+        end
+      end
+
+      def headers
+        report.class::HEADERS.keys.collect do |header|
+          header_description = {
+            name: Spree.t(header.to_sym, scope: [:insight, report.name]),
+            value: header,
+            type: report.class::HEADERS[header],
+            sortable: header.in?(report.class::SORTABLE_ATTRIBUTES)
+          }
+          header_description[:sorted] = report.sort_direction if report.header_sorted?(header)
+          header_description
+        end
+      end
+
+      def time_dimension
+        case time_scale
+        when :hourly
+          :hour_name
+        when :daily
+          :day_name
+        when :monthly
+          :month_name
+        when :yearly
+          :year
+        end
+      end
+    end
+  end
+end

data/app/reports/spree/report/timed_observation.rb

@@ -0,0 +1,47 @@
+class Spree::Report::TimedObservation < Spree::Report::Observation
+
+  extend Forwardable
+
+  attr_accessor :date, :hour, :reportable_keys
+
+  def_delegators :date, :day, :month, :year
+
+  def initialize
+    super
+    self.hour = 0
+  end
+
+  def describes?(result, time_scale)
+    case time_scale
+    when :hourly
+      result['hour'] == hour && result['day'] == day
+    when :daily
+      result['day'] == day && result['month'] == month
+    when :monthly
+      result['month'] == month && result['year'] == year
+    when :yearly
+      result['year'] == year
+    end
+  end
+
+  def month_name
+    Date::MONTHNAMES[month]
+  end
+
+  def hour_name
+    if hour == 23
+      return "23:00 - 00:00"
+    else
+      return "#{ hour }:00 - #{ hour + 1 }:00"
+    end
+  end
+
+  def day_name
+    "#{ day } #{ month_name }"
+  end
+
+  def to_h
+    super.merge({day_name: day_name, month_name: month_name, year: year, hour_name: hour_name})
+  end
+
+end

data/app/reports/spree/report/timed_result.rb

@@ -0,0 +1,48 @@
+module Spree
+  class Report
+    class TimedResult < Result
+
+      def build_report_observations
+        query_results
+        build_empty_observations
+        populate_observations
+      end
+
+      def build_empty_observations
+        @observations = Spree::Report::DateSlicer.slice_into(start_date, end_date, time_scale, self.class::Observation)
+      end
+
+      def populate_observations
+        observation_iter = @observations.each
+        current_observation = @observations.present? ? observation_iter.next : nil
+        @results.each do |result|
+          if current_observation.present?
+            begin
+              until current_observation.describes? result, time_scale
+                current_observation = observation_iter.next
+              end
+
+              current_observation.populate(result)
+              current_observation = observation_iter.next
+            rescue StopIteration
+              break
+            end
+          end
+        end
+      end
+
+      def headers
+        [time_headers] + super
+      end
+
+      private def time_headers
+        {
+          name: Spree.t(time_dimension, scope: [:admin]),
+          value: time_dimension,
+          type: :string,
+          sortable: false
+        }
+      end
+    end
+  end
+end

data/app/reports/spree/returned_products_report.rb

@@ -0,0 +1,37 @@
+module Spree
+  class ReturnedProductsReport < Spree::Report
+    DEFAULT_SORTABLE_ATTRIBUTE = :product_name
+    HEADERS                    = { sku: :string, product_name: :string, return_count: :integer }
+    SEARCH_ATTRIBUTES          = { start_date: :product_returned_from, end_date: :product_returned_till }
+    SORTABLE_ATTRIBUTES        = [:product_name, :sku, :return_count]
+
+    deeplink product_name: { template: %Q{<a href="/admin/products/{%# o.product_slug %}" target="_blank">{%# o.product_name %}</a>} }
+
+    class Result < Spree::Report::Result
+      class Observation < Spree::Report::Observation
+        observation_fields [:sku, :product_name, :return_count, :product_slug]
+
+        def sku
+          @sku.presence || @product_name
+        end
+      end
+    end
+
+    def report_query
+      Spree::ReturnAuthorization
+        .joins(:return_items)
+        .joins(:inventory_units)
+        .joins(:variants)
+        .joins(:products)
+        .where(spree_return_items: { created_at: reporting_period })
+        .group('spree_variants.id', 'spree_products.name', 'spree_products.slug', 'spree_variants.sku')
+        .select(
+          'spree_products.name       as product_name',
+          'spree_products.slug       as product_slug',
+          'spree_variants.sku        as sku',
+          'COUNT(spree_variants.id)  as return_count'
+        )
+    end
+
+  end
+end

data/app/reports/spree/sales_performance_report.rb

@@ -0,0 +1,107 @@
+module Spree
+  class SalesPerformanceReport < Spree::Report
+    HEADERS             = { sale_price: :integer, cost_price: :integer, promotion_discount: :integer, profit_loss: :integer, profit_loss_percent: :integer }
+    SEARCH_ATTRIBUTES   = { start_date: :orders_created_from, end_date: :orders_created_till }
+    SORTABLE_ATTRIBUTES = []
+
+    class Result < Spree::Report::TimedResult
+      charts ProfitLossChart, ProfitLossPercentChart, SaleCostPriceChart
+
+      class Observation < Spree::Report::TimedObservation
+        observation_fields cost_price: 0, sale_price: 0, profit_loss: 0, profit_loss_percent: 0, promotion_discount: 0
+
+        def cost_price
+          @cost_price.to_f
+        end
+
+        def sale_price
+          @sale_price.to_f
+        end
+
+        def profit_loss
+          @profit_loss.to_f
+        end
+
+        def profit_loss_percent
+          return (profit_loss * 100 / cost_price).round(2) unless cost_price.zero?
+          0.0
+        end
+
+        def promotion_discount
+          @promotion_discount.to_f
+        end
+      end
+
+    end
+
+    private def report_query
+      Spree::Report::QueryFragments
+        .from_union(order_with_line_items_grouped_by_time, promotions_grouped_by_time)
+        .group(*time_scale_columns_to_s)
+        .order(*time_scale_columns)
+        .project(
+          *time_scale_columns,
+          'SUM(sale_price) as sale_price',
+          'SUM(cost_price) as cost_price',
+          'SUM(profit_loss) as profit_loss',
+          'SUM(promotion_discount) as promotion_discount'
+        )
+    end
+
+    private def promotions_grouped_by_time
+      Spree::Report::QueryFragments
+        .from_subquery(promotion_adjustments_with_time)
+        .group(*time_scale_columns_to_s, 'sale_price', 'cost_price')
+        .order(*time_scale_columns)
+        .project(
+          *time_scale_columns,
+          '0 as sale_price',
+          '0 as cost_price',
+          'SUM(promotion_discount) * -1 as profit_loss',
+          'SUM(promotion_discount) as promotion_discount'
+        )
+    end
+
+    private def promotion_adjustments_with_time
+      Spree::Adjustment
+        .promotion
+        .where(created_at: reporting_period)
+        .select(
+          'abs(amount) as promotion_discount',
+          *time_scale_selects('spree_adjustments')
+        )
+    end
+
+    private def order_with_line_items_grouped_by_time
+      order_with_line_items_ar = Arel::Table.new(:order_with_line_items)
+      zero = Arel::Nodes.build_quoted(0.0)
+      Spree::Report::QueryFragments
+        .from_subquery(order_with_line_items, as: :order_with_line_items)
+        .group(*time_scale_columns_to_s)
+        .order(*time_scale_columns)
+        .project(
+          *time_scale_columns,
+          Spree::Report::QueryFragments.if_null(Spree::Report::QueryFragments.sum(order_with_line_items_ar[:sale_price]), zero).as('sale_price'),
+          Spree::Report::QueryFragments.if_null(Spree::Report::QueryFragments.sum(order_with_line_items_ar[:cost_price]), zero).as('cost_price'),
+          Spree::Report::QueryFragments.if_null(Spree::Report::QueryFragments.sum(order_with_line_items_ar[:profit_loss]), zero).as('profit_loss'),
+          '0 as promotion_discount'
+        )
+    end
+
+    private def order_with_line_items
+      line_item_ar = Spree::LineItem.arel_table
+      Spree::Order
+        .where.not(completed_at: nil)
+        .where(created_at: reporting_period)
+        .joins(:line_items)
+        .group('spree_orders.id', *time_scale_columns_to_s)
+        .select(
+          *time_scale_selects('spree_orders'),
+          "spree_orders.item_total as sale_price",
+          "SUM(#{ Spree::Report::QueryFragments.if_null(line_item_ar[:cost_price], line_item_ar[:price]).to_sql } * spree_line_items.quantity) as cost_price",
+          "(spree_orders.item_total - SUM(#{ Spree::Report::QueryFragments.if_null(line_item_ar[:cost_price], line_item_ar[:price]).to_sql } * spree_line_items.quantity)) as profit_loss"
+        )
+    end
+
+  end
+end