ahoy_captain 0.91 → 1.0.0

data/app/controllers/ahoy_captain/stats/base_controller.rb

@@ -1,7 +1,6 @@
 module AhoyCaptain
   module Stats
     class BaseController < ApplicationController
-      include Rangeable
 
       INTERVAL_PERIOD = {
         "realtime" => ["minute"],
@@ -12,8 +11,18 @@ module AhoyCaptain
       }
 
       INTERVALS = ["minute", "hour", "day", "week", "month"]
+
       private
 
+      helper_method :metric_type
+      def metric_type(stats)
+        if compare_mode?
+          stats.current.values.first.try(:class) || stats.compared_to.values.first.try(:class)
+        else
+          stats.values.first.class
+        end
+      end
+
       helper_method :selected_interval
       def selected_interval
         if params[:interval].in?(INTERVALS)
@@ -32,11 +41,13 @@ module AhoyCaptain
           # assume we're in a realtime
           return INTERVAL_PERIOD["realtime"][0]
         end
-        diff = (range[1] - range[0]).seconds.in_days.to_i
-        if diff > 30
+        diff = (range[1] - range[0]).seconds.in_days
+        if diff >= 31
           "month"
-        elsif diff > 0
+        elsif diff > 1
           "day"
+        elsif diff == 1
+          "hour"
         else
           "hour"
         end
@@ -49,7 +60,7 @@ module AhoyCaptain
 
           diff = (range[1] - range[0]).seconds.in_days
 
-          if diff == 0
+          if diff < 1
             INTERVAL_PERIOD["day"]
           elsif diff <= 7
             INTERVAL_PERIOD["7d"]
@@ -62,6 +73,76 @@ module AhoyCaptain
           INTERVAL_PERIOD["month"]
         end
       end
+
+      def lazy_window(result, value = 0, base = nil)
+        if result.is_a?(AhoyCaptain::LazyComparableQuery::LazyComparison)
+          result.result.current = lazy_window(result.result.current, value, range)
+          result.result.compared_to = lazy_window(result.result.compared_to, value, result.compare_range)
+          return result.result
+        end
+
+        base ||= range
+        window = window_for(selected_interval, result.keys[0].class, base.numeric)
+
+        window.each do |item|
+          if result.key?(item)
+            next
+          end
+
+          result[item] ||= value
+        end
+
+        transform = interval_label_transformation(selected_interval)
+
+        if transform
+          result.transform_keys! { |key| key.strftime(transform) }
+        end
+
+        result
+      end
+
+      def interval_label_transformation(interval)
+        return nil
+        if interval == 'hour'
+          return '%H:%M %p'
+        end
+
+        nil
+      end
+
+      # base should be a range
+      def window_for(interval, type, base = nil)
+        function = case type.to_s
+                    when 'Date', 'NilClass'
+                      ->(value) {
+                        date = Time.at(value).utc
+                        if interval == 'month'
+                          date.change(day: 1)
+                        elsif interval == 'week'
+                          date.beginning_of_week
+                        elsif interval == 'day'
+                          date.beginning_of_day
+                        elsif interval == 'hour'
+                          date.beginning_of_hour
+                        elsif interval == 'minute'
+                          date.beginning_of_minute
+                        else
+                          abort
+                        end.to_date
+                      }
+                    when 'DateTime'
+                      ->(value) { Time.at(value).utc.change(sec: 0) }
+                   when 'ActiveSupport::TimeWithZone'
+                     ->(value) { Time.at(value).utc }
+                   else
+                        raise ArgumentError
+                    end
+
+        base
+             .step(1.send(interval))
+             .to_a
+             .map { |value| function.call(value) }
+      end
     end
   end
 end

data/app/controllers/ahoy_captain/stats/bounce_rates_controller.rb

@@ -4,7 +4,7 @@ module AhoyCaptain
       # @todo: this is lazy
       def index
         @stats = AhoyCaptain::Stats::BounceRatesQuery.call(params)
-        @stats = @stats.group_by_period(selected_interval, "daily_bounce_rate.date").average("bounce_rate")
+        @stats = lazy_window(@stats.with_lazy_comparison(compare_mode?).group_by_period(selected_interval, "daily_bounce_rate.date").average("bounce_rate"))
         @label = "Bounce Rate"
       end
     end

data/app/controllers/ahoy_captain/stats/total_pageviews_controller.rb

@@ -2,7 +2,7 @@ module AhoyCaptain
   module Stats
     class TotalPageviewsController < BaseController
       def index
-        @stats = AhoyCaptain::Stats::TotalPageviewsQuery.call(params).group_by_period(selected_interval, :time).count
+        @stats = lazy_window(AhoyCaptain::Stats::TotalPageviewsQuery.call(params).with_lazy_comparison(compare_mode?).group_by_period(selected_interval, :time).count, 0)
         @label = "Visitors"
       end
     end

data/app/controllers/ahoy_captain/stats/total_visits_controller.rb

@@ -2,7 +2,7 @@ module AhoyCaptain
   module Stats
     class TotalVisitsController < BaseController
       def index
-        @stats = AhoyCaptain::Stats::TotalVisitorsQuery.call(params).group_by_period(selected_interval, :started_at).count
+        @stats = lazy_window(AhoyCaptain::Stats::TotalVisitorsQuery.call(params).with_lazy_comparison(compare_mode?).group_by_period(selected_interval, :started_at).count)
         @label = "Visitors"
       end
     end

data/app/controllers/ahoy_captain/stats/unique_visitors_controller.rb

@@ -2,7 +2,8 @@ module AhoyCaptain
   module Stats
     class UniqueVisitorsController < BaseController
       def index
-        @stats = AhoyCaptain::Stats::UniqueVisitorsQuery.call(params).group_by_period(selected_interval, :started_at).count
+        @stats = AhoyCaptain::Stats::UniqueVisitorsQuery.call(params).with_lazy_comparison(compare_mode?).group_by_period(selected_interval, :started_at).count
+        @stats = lazy_window(@stats)
         @label = "Visitors"
       end
     end

data/app/controllers/ahoy_captain/stats/views_per_visits_controller.rb

@@ -1,19 +1,10 @@
 module AhoyCaptain
   module Stats
     class ViewsPerVisitsController < BaseController
-      # @todo: make me a window func
       def index
-        @stats = AhoyCaptain::Stats::ViewsPerVisitQuery.call(params).group_by_period(selected_interval, 'views_per_visit_table.started_at').average(:views_per_visit)
-        if range[1]
-          (range[0].to_date..range[1].to_date).to_a.each do |date|
-            unless @stats.key?(date.to_date)
-              @stats[date.to_date] = 2
-            end
-          end
-        end
+        @stats = lazy_window(AhoyCaptain::Stats::ViewsPerVisitQuery.call(params).with_lazy_comparison(compare_mode?).group_by_period(selected_interval, 'views_per_visit_table.started_at').average(:views_per_visit))
 
         @label = "Views"
-
       end
     end
   end

data/app/controllers/ahoy_captain/stats/visit_durations_controller.rb

@@ -2,7 +2,7 @@ module AhoyCaptain
   module Stats
     class VisitDurationsController < BaseController
       def index
-        @stats = AhoyCaptain::Stats::VisitDurationQuery.call(params).group_by_period(selected_interval, 'started_at').average(:duration)
+        @stats = lazy_window(AhoyCaptain::Stats::VisitDurationQuery.call(params).with_lazy_comparison(compare_mode?).group_by_period(selected_interval, 'started_at').average(:duration))
         @label = "Duration"
       end
     end

data/app/helpers/ahoy_captain/application_helper.rb

@@ -2,8 +2,35 @@ module AhoyCaptain
   module ApplicationHelper
     include Pagy::Frontend
 
-    # params that are coerced from the ApplicationController#act_like_an_spa
-    SPECIAL_PARAMS = [:campaigns_type, :devices_type]
+    def current_property_filter
+      return nil unless params[:q]
+
+      prop = params[:q].to_unsafe_h.detect { |key, _| key.starts_with?("properties.") }
+      if prop
+        key = prop[0].dup
+        Ransack::Predicate.detect_and_strip_from_string!(key)
+        { key: key, value: prop[1] }
+
+      else
+        nil
+      end
+    end
+
+    def stats_container(value, url, label, formatter, selected = false)
+      if value.is_a?(AhoyCaptain::ComparableQuery::Comparison)
+        ::AhoyCaptain::Stats::ComparableContainerComponent.new(url, label, value, formatter, selected, compare_mode?)
+      else
+        ::AhoyCaptain::Stats::ContainerComponent.new(url, label, value, formatter, selected)
+      end
+    end
+
+    def number_to_duration(duration)
+      if duration
+        "#{duration.in_minutes.to_i}M #{duration.parts[:seconds].to_i}S"
+      else
+        "0M 0S"
+      end
+    end
 
     def ahoy_captain_importmap_tags(entry_point = "application", shim: true)
       safe_join [
@@ -19,10 +46,6 @@ module AhoyCaptain
       request.query_parameters
     end
 
-    def special_params
-      params.to_unsafe_h.slice(*SPECIAL_PARAMS)
-    end
-
     # gets put into the form as a hidden field
     #
     def non_filter_ransack_params
@@ -31,9 +54,11 @@ module AhoyCaptain
         :start_date,
         :end_date,
         :period,
-        :interval
+        :interval,
+        :comparison,
       ]
 
+      # properties stuff falls into current_property_filter
       ransack = [:goal]
 
       map.each do |key|
@@ -45,8 +70,7 @@ module AhoyCaptain
       ransack.each do |key|
         Ransack.predicates.keys.each do |predicate|
           if value = params.dig(:q, "#{key}_#{predicate}")
-            other_params[:q] ||= {}
-            other_params[:q]["#{key}_#{predicate}"] = value
+            other_params["q[#{key}_#{predicate}]"] = value
           end
         end
       end

data/app/models/ahoy_captain/comparison_mode.rb

@@ -0,0 +1,72 @@
+module AhoyCaptain
+  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/ahoy_captain/filter_parser.rb

@@ -26,24 +26,9 @@ module AhoyCaptain
 
     def parse
       @filter_params.each do |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 = AhoyCaptain.config.filters.detect { |_, filters| filters.include?(item.column) }[1].modal_name
-        if modal_name
-          item.modal = modal_name
-        end
-
-        label = if item.column == "goal"
-          AhoyCaptain.config.goals[values].title
-        else
-          item.values.to_sentence(last_word_connector: " or ")
-        end
-        item.label = label
-        item.description = "#{item.column.titleize} #{::AhoyCaptain::PredicateLabel[item.predicate]} #{label}"
-        item.url = build_url(key, values)
+        next if ::AhoyCaptain.event.ransackable_scopes.include?(key.to_sym)
+
+        item = build_item(key, values)
         @items[key] = item
       end
 
@@ -52,6 +37,36 @@ module AhoyCaptain
 
     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 = AhoyCaptain.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| AhoyCaptain.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} #{::AhoyCaptain::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)

data/app/models/ahoy_captain/range_from_params.rb

@@ -0,0 +1,78 @@
+module AhoyCaptain
+  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: AhoyCaptain.config.ranges.default, start_date: nil, end_date: nil, date: nil, comparison: false, raw: {})
+      @period = period || AhoyCaptain.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 AhoyCaptain.config.ranges.max && (duration.days <= AhoyCaptain.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
+      AhoyCaptain.config.ranges.for(@period) || AhoyCaptain.config.ranges.default
+    end
+  end
+end

data/app/models/ahoy_captain/rangeable.rb

@@ -1,10 +1,7 @@
 module AhoyCaptain
   module Rangeable
-    include AhoyCaptain::RangeOptions
-
     def period
       params[:period] || AhoyCaptain.config.ranges.default
     end
-
   end
 end

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

@@ -0,0 +1,19 @@
+module AhoyCaptain
+  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/ahoy_captain/limitable.rb

@@ -0,0 +1,17 @@
+module AhoyCaptain
+  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/ahoy_captain/range_options.rb

@@ -1,21 +1,8 @@
 module AhoyCaptain
   module RangeOptions
 
-    def period
-      raise NotImplementedError
-    end
-
     private def range
-      if params[:start_date].present? && params[:end_date].present?
-        custom = [params[:start_date].to_datetime, params[:end_date].to_datetime].sort
-        duration = (custom[1].to_date -  custom[0].to_date)
-
-        if AhoyCaptain.config.ranges.max && (duration.days <= AhoyCaptain.config.ranges.max)
-          return custom
-        end
-      end
-
-      AhoyCaptain.config.ranges.for(period)
+      RangeFromParams.from_params(params)
     end
   end
 end

data/app/presenters/ahoy_captain/dashboard_presenter.rb

@@ -1,6 +1,8 @@
 module AhoyCaptain
   class DashboardPresenter
+    include Rangeable
     include RangeOptions
+    include CompareMode
 
     attr_reader :params
 
@@ -9,81 +11,43 @@ module AhoyCaptain
     end
 
     def unique_visitors
-      cached(:unique_visitors) do
-        Stats::UniqueVisitorsQuery.call(params).count(:visitor_token)
-      end
+      Stats::UniqueVisitorsQuery.call(params).with_comparison(compare_mode?).count
     end
 
     def total_visits
-      cached(:total_visits) do
-        Stats::TotalVisitorsQuery.call(params).count(:id)
-      end
+      Stats::TotalVisitorsQuery.call(params).with_comparison(compare_mode?).count
     end
 
     def total_pageviews
-      cached(:total_pageviews) do
-        Stats::TotalPageviewsQuery.call(params).count(:id)
-      end
+      Stats::TotalPageviewsQuery.call(params).with_comparison(compare_mode?).count
     end
 
     def views_per_visit
-      cached(:views_per_visit) do
-        begin
-          result = Stats::AverageViewsPerVisitQuery.call(params).count(:id)
-          count = (result.values.sum.to_f / result.size).round(2)
-          if count.nan?
-            return "0"
-          else
-            return count
-          end
-        rescue ::ActiveRecord::StatementInvalid => e
-          if e.message.include?("PG::DivisionByZero")
-            return "0"
-          else
-            raise e
-          end
-        end
-      end
+      Stats::AverageViewsPerVisitQuery.call(params).with_comparison(compare_mode?).average("count")
     end
 
     def bounce_rate
-      cached(:bounce_rate) do
-        begin
-          result = Stats::BounceRatesQuery.call(params)
-          average = result.average("bounce_rate")
-          if average
-            average.round(2)
-          else
-            "0"
-          end
-        rescue ::ActiveRecord::StatementInvalid => e
-          if e.message.include?("PG::DivisionByZero")
-            return "0"
-          else
-            raise e
-          end
-        end
+      query = Stats::BounceRatesQuery.call(params)
+      if compare_mode?
+        query.with_comparison(true)
+      else
+        query.average("bounce_rate").try(:round, 2) || 0
       end
     end
 
     def visit_duration
-      cached(:visit_duration) do
-        result = Stats::AverageVisitDurationQuery.call(params)
-        duration = result[0].average_visit_duration
-        if duration
-          "#{duration.in_minutes.to_i}M #{duration.parts[:seconds].to_i}S"
-        else
-          "0M 0S"
-        end
+      query = Stats::AverageVisitDurationQuery.call(params)
+      if compare_mode?
+        query.with_comparison(true)
+      else
+        query[0].average_visit_duration
       end
     end
 
     private
 
-    def cached(*names)
-      AhoyCaptain.cache.fetch("ahoy_captain:#{names.join(":")}:#{params.permit!.except("controller", "action").to_unsafe_h.map { |k,v| "#{k}-#{v}" }.join(":")}", expire_in: AhoyCaptain.config.cache[:ttl]) do
-        yield
-      end
+    def compare_mode?
+      params[:comparison] != 'false'
     end
   end
 end