lookout-ahoy 0.1.0

data/app/models/concerns/lookout/compare_mode.rb

@@ -0,0 +1,19 @@
+module Lookout
+  module CompareMode
+    def self.included(klass)
+      if klass < ActionController::Base
+        klass.helper_method :compare_mode?
+        klass.helper_method :comparison_label
+      end
+    end
+
+    # doesn't work for realtime and realtime doesn't need a secondary range
+    def compare_mode?
+      comparison_mode.enabled?
+    end
+
+    def comparison_mode
+      @comparison_mode ||= ComparisonMode.new(params)
+    end
+  end
+end

data/app/models/concerns/lookout/limitable.rb

@@ -0,0 +1,17 @@
+module Lookout
+  module Limitable
+    private
+
+    def limit
+      if request.variant.include?(:details)
+        nil
+      else
+        if params[:limit]
+          params[:limit].to_i
+        else
+          10
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/lookout/range_options.rb

@@ -0,0 +1,8 @@
+module Lookout
+  module RangeOptions
+
+    private def range
+      RangeFromParams.from_params(params)
+    end
+  end
+end

data/app/models/lookout/comparison_mode.rb

@@ -0,0 +1,72 @@
+module Lookout
+  class ComparisonMode
+    VALID_COMPARISONS = %w{previous year true}
+
+    include RangeOptions
+    include Rangeable
+
+    attr_reader :params
+    def initialize(params)
+      @params = params
+    end
+
+    # can't compare realtime
+    def enabled?(strict = true)
+      comparing = (params[:comparison].in?(VALID_COMPARISONS) || custom_compare?)
+      if strict
+        comparing && !range.realtime?
+      else
+        comparing
+      end
+    end
+
+    def label
+      if custom_compare?
+        return "Custom period"
+      end
+
+      if type == :true || type == :previous
+        "Previous period"
+      elsif type == :year
+        "Year-over-year"
+      else
+        raise ArgumentError
+      end
+    end
+
+    def compared_to_range
+      return custom_compare if custom_compare?
+
+      if type == :true || type == :previous
+        RangeFromParams.new(period: nil, start_date: (range[0] - (range[1] - range[0])).utc.to_s, end_date: range[0].utc.to_s).build
+      elsif type == :year
+        RangeFromParams.new(period: nil, start_date: range[0].change(year: range[0].year - 1).utc.to_s, end_date: range[1].change(year: range[1].year - 1).utc.to_s).build
+      else
+        raise ArgumentError
+      end
+    end
+
+    def type
+      return params[:comparison].to_sym if params[:comparison].in?(VALID_COMPARISONS)
+      return :custom if custom_compare?
+
+      nil
+    end
+
+    def match_to
+      return params[:compare_to].to_sym if params[:compare_to].in?(%w{dow date})
+
+      nil
+    end
+
+    def custom_compare
+      return nil unless (params[:compare_to_start_date].present? && params[:compare_to_end_date].present?)
+
+      RangeFromParams.new(period: nil, start_date: params[:compare_to_start_date], end_date: params[:compare_to_end_date]).build
+    end
+
+    def custom_compare?
+      custom_compare
+    end
+  end
+end

data/app/models/lookout/export.rb

@@ -0,0 +1,48 @@
+module Lookout
+  class Export
+    def initialize(params, context)
+      @params = params
+      @context = context
+      @files = {}
+    end
+
+    def build
+      @files["browsers.csv"] = to_csv(DeviceQuery.call(merged_params(devices_type: "browser")), DeviceDecorator)
+      @files["cities.csv"] = to_csv(CityQuery.call(merged_params), CityDecorator)
+      @files["countries.csv"] = to_csv(CountryQuery.call(merged_params), CountryDecorator)
+      @files["devices.csv"] = to_csv(DeviceQuery.call(merged_params(devices_type: :device_type)), DeviceDecorator)
+      @files["entry_pages.csv"] = to_csv(EntryPagesQuery.call(merged_params), EntryPageDecorator)
+      @files["exit_pages.csv"] = to_csv(ExitPagesQuery.call(merged_params), ExitPageDecorator)
+      @files["operating_systems.csv"] = to_csv(DeviceQuery.call(merged_params(devices_type: "os")), DeviceDecorator)
+      @files["top_pages.csv"] = to_csv(TopPageQuery.call(merged_params), TopPageDecorator)
+      @files["regions.csv"] = to_csv(RegionQuery.call(merged_params), RegionDecorator)
+      @files["sources.csv"] = to_csv(SourceQuery.call(merged_params), SourceDecorator)
+      ["campaign", "content", "medium", "source", "term"].each do |utm|
+        @files["utm_#{utm.pluralize}.csv"] = to_csv(CampaignQuery.call(merged_params(campaigns_type: "utm_#{utm}")), CampaignDecorator)
+      end
+      self
+    end
+
+    def to_zip
+      zip_stream = Zip::OutputStream.write_buffer do |zip|
+        @files.each do |filename, csv|
+          zip.put_next_entry(filename)
+          zip.write(csv)
+        end
+      end
+
+      zip_stream.rewind
+      zip_stream
+    end
+
+    private
+
+    def to_csv(query, decorator)
+      decorator.to_csv(query, @context)
+    end
+
+    def merged_params(params_to_merge = {})
+      @params.dup.merge(params_to_merge)
+    end
+  end
+end

data/app/models/lookout/filter_parser.rb

@@ -0,0 +1,82 @@
+module Lookout
+  class FilterParser
+    FILTER_MENU_MAX_SIZE = 2
+    class Item
+      attr_accessor :name, :column, :description, :values, :predicate, :url, :modal, :label
+
+      def title
+        column.titleize
+      end
+    end
+
+    def self.parse(request)
+      new(request).tap do |instance|
+        instance.parse
+      end
+    end
+
+    delegate_missing_to :@items
+
+    def initialize(request)
+      @request = request
+      @params = @request.params
+      @filter_params = @request.params[:q] || {}
+      @items = {}
+    end
+
+    def parse
+      @filter_params.each do |key, values|
+        next if ::Lookout.event.ransackable_scopes.include?(key.to_sym)
+
+        item = build_item(key, values)
+        @items[key] = item
+      end
+
+      @items
+    end
+
+    private
+
+    def build_item(key, values)
+      item = Item.new
+      item.values = Array(values)
+
+      item.predicate = Ransack::Predicate.detect_and_strip_from_string!(key.dup)
+      item.column = key.delete_suffix("_#{item.predicate}")
+      modal_name = Lookout.config.filters.detect { |_, filters| filters.include?(item.column) }
+      if modal_name
+        item.modal = modal_name[1].modal_name
+      end
+
+      label = if item.column == "goal"
+                item.values.map { |value| Lookout.config.goals[value].title }
+              else
+                item.values
+              end.to_sentence(last_word_connector: " or ")
+
+      item.label = if key.start_with?("properties.")
+                           item.modal = "customPropertyFilterModal"
+                           item.column = item.column.dup.delete_prefix("properties.")
+                           label
+                         else
+                           label
+                          end
+
+      item.description = "#{item.label} #{::Lookout::PredicateLabel[item.predicate]} #{label}"
+      item.url = build_url(key, values)
+      item
+    end
+
+    def build_url(name, values)
+      search_params = @request.query_parameters.deep_dup
+      if search_params["q"][name].is_a?(Array)
+        search_params["q"][name] = search_params["q"][name] - Array(values)
+      else
+        search_params["q"].delete(name)
+      end
+
+      @request.path + "?" + search_params.to_query
+    end
+
+  end
+end

data/app/models/lookout/range_from_params.rb

@@ -0,0 +1,78 @@
+module Lookout
+  class RangeFromParams
+    def self.from_params(params)
+      compare = ComparisonMode.new(params)
+      new(period: params[:period], start_date: params[:start_date], end_date: params[:end_date], date: params[:date], comparison: compare.enabled?(false), raw: params).tap { |instance| instance.build }
+    end
+
+    attr_reader :params, :range
+    def initialize(period: Lookout.config.ranges.default, start_date: nil, end_date: nil, date: nil, comparison: false, raw: {})
+      @period = period || Lookout.config.ranges.default
+      @start_date = start_date
+      @end_date = end_date
+      @date = date
+      @range = nil
+      @comparison = comparison
+      @raw = raw
+    end
+
+    def build
+      if (@start_date.present? && @end_date.present?) || @date.present?
+        if @date
+          @start_date ||= @date.to_datetime.beginning_of_day
+          @end_date ||= @date.to_datetime.end_of_day
+        end
+
+        custom = [@start_date.to_datetime, @end_date.to_datetime].sort
+        duration = (custom[1].to_date -  custom[0].to_date)
+
+        #   if Lookout.config.ranges.max && (duration.days <= Lookout.config.ranges.max)
+          @range = Range.new(custom[0].utc, custom[1].utc)
+          return self
+        #   end
+      end
+
+      @range = Range.new(selected_period[0], selected_period[1])
+      self
+    end
+
+    def starts_at
+      Time.at(@range.min)
+    end
+
+    def ends_at
+      if realtime?
+        Time.current
+      else
+        Time.at(@range.max)
+      end
+    end
+
+    def realtime?
+      @range.end.nil?
+    end
+
+    def custom?
+      @raw[:start_date].present? && @raw[:end_date].present?
+    end
+
+    def [](value)
+      if value == 0
+        starts_at
+      elsif value == 1
+        ends_at
+      else
+        raise NoMethodError
+      end
+    end
+
+    # return an integer-based range which works with step
+    def numeric
+      @numeric ||= Range.new(starts_at.to_i, ends_at.to_i)
+    end
+
+    def selected_period
+      Lookout.config.ranges.for(@period) || Lookout.config.ranges.default
+    end
+  end
+end

data/app/models/lookout/rangeable.rb

@@ -0,0 +1,7 @@
+module Lookout
+  module Rangeable
+    def period
+      params[:period] || Lookout.config.ranges.default
+    end
+  end
+end

data/app/models/lookout/widget.rb

@@ -0,0 +1,15 @@
+module Lookout
+  class Widget
+    class WidgetDisabled < StandardError
+      attr_reader :frame
+      def initialize(msg, frame = nil)
+        @frame = frame
+        super(msg)
+      end
+    end
+
+    def self.disabled?(*names)
+      Lookout.config.disabled_widgets.include?(names.join("."))
+    end
+  end
+end

data/app/presenters/lookout/dashboard_presenter.rb

@@ -0,0 +1,53 @@
+module Lookout
+  class DashboardPresenter
+    include Rangeable
+    include RangeOptions
+    include CompareMode
+
+    attr_reader :params
+
+    def initialize(params)
+      @params = params
+    end
+
+    def unique_visitors
+      Stats::UniqueVisitorsQuery.call(params).with_comparison(compare_mode?).count
+    end
+
+    def total_visits
+      Stats::TotalVisitorsQuery.call(params).with_comparison(compare_mode?).count
+    end
+
+    def total_pageviews
+      Stats::TotalPageviewsQuery.call(params).with_comparison(compare_mode?).count
+    end
+
+    def views_per_visit
+      Stats::AverageViewsPerVisitQuery.call(params).with_comparison(compare_mode?).average("count")
+    end
+
+    def bounce_rate
+      query = Stats::BounceRatesQuery.call(params)
+      if compare_mode?
+        query.with_comparison(true).average("bounce_rate")
+      else
+        query.average("bounce_rate").try(:round, 2) || 0
+      end
+    end
+
+    def visit_duration
+      query = Stats::AverageVisitDurationQuery.call(params)
+      if compare_mode?
+        query.with_comparison(true)
+      else
+        query[0].average_visit_duration
+      end
+    end
+
+    private
+
+    def compare_mode?
+      params[:comparison] != 'false'
+    end
+  end
+end

data/app/presenters/lookout/funnel_presenter.rb

@@ -0,0 +1,75 @@
+module Lookout
+  # this is incredibly naive and needs some tlc
+  class FunnelPresenter
+
+    attr_reader :steps
+    def initialize(funnel, event_query)
+      @funnel = funnel
+      @event_query = event_query.joins(:visit)
+    end
+
+    def build
+      if Lookout.config.goals.none? || @funnel.goals.none?
+        @steps = []
+        return self
+      end
+
+      queries = {
+        totals: @event_query.select("count(distinct(#{Lookout.event.table_name}.visit_id)) as unique_visits, '_internal_total_visits_' as name, count(distinct #{Lookout.event.table_name}.id) as total_events, 0 as sort_order")
+      }
+      selects = ["SELECT unique_visits, name, total_events, sort_order from totals"]
+      last_goal = nil
+      map = {}.with_indifferent_access
+
+      # Use funnel's goals in order, not all configured goals
+      @funnel.goals.each_with_index do |goal, index|
+        queries[goal.id] = @event_query.select("count(distinct(#{Lookout.event.table_name}.visit_id)) as unique_visits, '#{goal.id}' as name, count(distinct #{Lookout.event.table_name}.id) as total_events, #{index + 1} as sort_order").merge(goal.event_query.call).group("#{Lookout.event.table_name}.name")
+        selects << ["SELECT unique_visits, name, total_events, sort_order from #{goal.id}"]
+        map[goal.id] = goal
+        last_goal = goal
+      end
+
+      # activerecord quirk / with bug
+      select = selects.join(" UNION ").delete_suffix(" from #{last_goal.id}")
+      select = select.delete_prefix("SELECT ")
+      steps = ::Ahoy::Event.with(
+        queries,
+        ).select(select).from("#{last_goal.id}").order("sort_order asc")
+
+      # Cast to numeric/real for division depending on database
+      cast_type = Lookout::DatabaseAdapter.postgresql? ? "::numeric" : ""
+      cast_division = Lookout::DatabaseAdapter.postgresql? ? 
+        "total_events::numeric/lag(total_events, 1) over ()" :
+        "CAST(total_events AS REAL)/lag(total_events, 1) over ()"
+      
+      items = ::Ahoy::Event.with(steps: steps).select("total_events, unique_visits, name, round((#{cast_division}),2) as drop_off").from("steps").order("sort_order asc").index_by(&:name)
+      items.delete("_internal_total_visits_")
+      @steps = []
+
+      items.values.each do |item|
+        if map[item.name]
+          item.name = map[item.name].title
+        end
+      end
+
+      @steps = items.values
+      self
+    end
+
+
+    def total
+      @event_query.distinct(:visitor_token).count
+    end
+
+    def as_json
+      {
+        steps: @steps.as_json,
+        total: total
+      }
+    end
+
+    def to_json
+      as_json.to_json
+    end
+  end
+end

data/app/presenters/lookout/goals_presenter.rb

@@ -0,0 +1,72 @@
+module Lookout
+  class GoalsPresenter
+    attr_reader :goals
+    def initialize(event_query)
+      @event_query = event_query
+      @goals = nil
+    end
+
+    # this is a dumpster fire
+    def build
+      if Lookout.config.goals.none?
+        @goals = []
+        return self
+      end
+
+      queries = {
+        totals: @event_query.select("count(distinct(#{Lookout.event.table_name}.visit_id)) as unique_visits, '_internal_total_visits_' as name, count(distinct #{Lookout.event.table_name}.id) as total_events, 0 as sort_order")
+      }
+      selects = ["SELECT unique_visits, name, total_events, sort_order, 0 as cr, '' as goal_id from totals"]
+      last_goal = nil
+      map = {}.with_indifferent_access
+
+      Lookout.config.goals.each_with_index do |goal, index|
+        queries[goal.id] = @event_query.select(
+          [
+            "count(distinct(#{Lookout.event.table_name}.visit_id)) as unique_visits" ,
+            "'#{goal.id}' as name",
+            "count(distinct #{Lookout.event.table_name}.id) as total_events",
+            "#{index + 1} as sort_order",
+            "'#{goal.id}' as goal_id"
+          ]
+        ).merge(goal.event_query.call).group("#{Lookout.event.table_name}.name")
+        # Cast 0 to decimal/real depending on database
+        zero_decimal = Lookout::DatabaseAdapter.postgresql? ? "0::decimal" : "0.0"
+        selects << ["SELECT unique_visits, name, total_events, sort_order, #{zero_decimal} as cr, '#{goal.id}' as goal_id from #{goal.id}"]
+        map[goal.id] = goal
+        last_goal = goal
+      end
+
+      # activerecord quirk / with bug
+      select = selects.join(" UNION ").delete_suffix(" from #{last_goal.id}")
+      select = select.delete_prefix("SELECT ")
+      steps = ::Ahoy::Event.with(
+        queries,
+        ).select(select).from("#{last_goal.id}").order("sort_order asc").index_by(&:name)
+      totals = steps.delete("_internal_total_visits_")
+
+      @goals = steps.keys.collect do |name|
+        step = steps[name]
+        step.name = map[name].title
+        step.cr = ((step.total_events.to_d / totals.total_events.to_d) * 100).round(2)
+        step
+      end
+      self
+    end
+
+    def total_visitors
+      @total_visitors ||= @event_query.select(:visit_id).distinct.count
+    end
+
+    def as_json
+      {
+        steps: @steps.as_json,
+        total: total
+      }
+    end
+
+    def to_json
+      as_json.to_json
+    end
+  end
+end

data/app/queries/concerns/lookout/comparable_queries.rb

@@ -0,0 +1,25 @@
+module Lookout
+  module ComparableQueries
+    def compare_range
+      @compare_range ||= begin
+                           ComparisonMode.new(@params).compared_to_range
+                         end
+    end
+
+    def range
+      @range ||= @query.send(:range)
+    end
+
+    def comparison_params
+      params = @params.deep_dup
+      params.delete("period")
+
+      params[:start_date] = compare_range[0]
+      params[:end_date] = compare_range[1]
+      params
+    end
+  end
+end
+
+require_relative './lazy_comparable_query'
+require_relative './comparable_query'