ahoy_captain 0.83 → 1.0.0

data/app/models/ahoy_captain/filter_parser.rb

@@ -0,0 +1,82 @@
+module AhoyCaptain
+  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 ::AhoyCaptain.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 = 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)
+        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/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

data/app/presenters/ahoy_captain/goals_presenter.rb

@@ -16,7 +16,7 @@ module AhoyCaptain
       queries = {
         totals: @event_query.select("count(distinct(#{AhoyCaptain.event.table_name}.visit_id)) as unique_visits, '_internal_total_visits_' as name, count(distinct #{AhoyCaptain.event.table_name}.id) as total_events, 0 as sort_order")
       }
-      selects = ["SELECT unique_visits, name, total_events, sort_order, 0 as cr from totals"]
+      selects = ["SELECT unique_visits, name, total_events, sort_order, 0 as cr, '' as goal_id from totals"]
       last_goal = nil
       map = {}.with_indifferent_access
 
@@ -27,9 +27,10 @@ module AhoyCaptain
             "'#{goal.id}' as name",
             "count(distinct #{AhoyCaptain.event.table_name}.id) as total_events",
             "#{index + 1} as sort_order",
+            "'#{goal.id}' as goal_id"
           ]
         ).merge(goal.event_query.call).group("#{AhoyCaptain.event.table_name}.name")
-        selects << ["SELECT unique_visits, name, total_events, sort_order, 0::decimal as cr from #{goal.id}"]
+        selects << ["SELECT unique_visits, name, total_events, sort_order, 0::decimal as cr, '#{goal.id}' as goal_id from #{goal.id}"]
         map[goal.id] = goal
         last_goal = goal
       end

data/app/queries/ahoy_captain/application_query.rb

@@ -1,8 +1,9 @@
+require_relative '../concerns/ahoy_captain/comparable_queries'
+
 module AhoyCaptain
   class ApplicationQuery
     # if you want to enforce returning a relation
     class_attribute :strict, default: true
-    include Rangeable
 
     delegate_missing_to :@query
 
@@ -63,7 +64,7 @@ module AhoyCaptain
           event: (AhoyCaptain.event.ransackable_attributes + AhoyCaptain.event.ransackable_scopes).map(&:to_s),
         }
 
-        pattern = /(?:_not_eq|_eq|_in|_not_in|_cont|_not_cont|_i_cont)$/
+        pattern = /(?:#{Ransack.predicates.sorted_names_with_underscores.to_h.values.join("|")})$/
         params[:q].each do |key, value|
           attribute_name = key.gsub(pattern, '')
           if type == :event && (ransackable_attributes[:visit].include?(attribute_name) || ransackable_attributes[:visit].include?(key))
@@ -76,35 +77,57 @@ module AhoyCaptain
         end
       end
 
+      merge_params = {}
+      ransackable_params.each do |k,v|
+        transform = false
+        if v == AhoyCaptain.none.value
+          transform = true
+        elsif v.is_a?(Array) && v[0] == AhoyCaptain.none.value
+          transform = true
+        end
+
+        if transform
+          key = k.dup
+          ransackable_params.delete(key)
+          predicate = Ransack::Predicate.detect_and_strip_from_string!(key)
+          if predicate.include?("not")
+            merge_params["#{key}_not_null"] = '1'
+          else
+            merge_params["#{key}_null"] = '1'
+          end
+        end
+      end
+
+      ransackable_params.merge!(merge_params)
       # send the right format
       #   ::Ahoy::Visit.ransack(events_time_lt: Time.now).result.to_sql
       # is not
       #   ::Ahoy::Visit.ransack(events_time_lt: Time.now.to_i).result.to_sql
       if range
         if type == :event
-          if range.size == 2
+          if range.realtime?
             ransackable_params['time_gt'] = range[0]
-            ransackable_params['time_lt'] = range[1]
             ransackable_params["visit_started_at_gt"] = range[0]
-            ransackable_params["visit_started_at_lt"] = range[1]
           else
             ransackable_params['time_gt'] = range[0]
+            ransackable_params['time_lt'] = range[1]
             ransackable_params["visit_started_at_gt"] = range[0]
+            ransackable_params["visit_started_at_lt"] = range[1]
           end
         elsif type == :visit
-          if range.size == 2
+          if range.realtime?
+            ransackable_params["started_at_gt"] = range[0]
+            ransackable_params["events_time_gt"] = range[0]
+          else
             ransackable_params["started_at_gt"] = range[0]
             ransackable_params["started_at_lt"] = range[1]
             ransackable_params["events_time_gteq"] = range[0]
             ransackable_params["events_time_lteq"] = range[1]
-          else
-            ransackable_params["started_at_gt"] = range[0]
-            ransackable_params["events_time_gt"] = range[0]
           end
         end
       end
 
-      ransackable_params
+      ransackify(ransackable_params, type)
     end
 
     # merge both sets of ransackable params and ensure that they're being set on the correct association
@@ -118,5 +141,46 @@ module AhoyCaptain
         raise ArgumentError, "use ransack_params_for(type)"
       end
     end
+
+    def ransackify(query, type)
+      return unless query
+
+      query = query.try(:permit!).try(:to_h) unless query.is_a?(Hash)
+      obj = query.each_with_object({}) do |(k, v), obj|
+        if k.starts_with?('properties.')
+          field = k.split('properties.').last
+          operation = Ransack::Predicate.detect_and_strip_from_string!(field)
+
+          raise ArgumentError, "No valid predicate for #{field}" unless operation
+
+          prefix = type == :event ? "" : "events_"
+          obj[:c] ||= []
+
+          obj[:c] << {
+            a: {
+              '0' => {
+                name: "#{prefix}properties",
+                ransacker_args: field
+              }
+            },
+            p: operation,
+            v: [v]
+          }
+
+        else
+          obj[k] = v
+        end
+      end
+
+      if type == :event
+        return obj
+      else
+        return obj
+      end
+    end
+
+    def range
+      RangeFromParams.from_params(params)
+    end
   end
 end

data/app/queries/ahoy_captain/event_query.rb

@@ -1,6 +1,5 @@
 module AhoyCaptain
   class EventQuery < ApplicationQuery
-    include Rangeable
 
     def build
       entry_pages = ransack_params_for(:event).select { |k,v| k.start_with?("entry_page") }
@@ -13,7 +12,7 @@ module AhoyCaptain
         ransack_params_for(:event).reject { |k,v| k.start_with?("visit_") }, context: shared_context
       )
 
-      visit_params = ransack_params_for(:visit).reject { |k,v| k.start_with?("event_") || k.start_with?("events_") }.transform_keys { |key| "visit_#{key}" }
+      visit_params = ransack_params_for(:visit).reject { |k,v| k.start_with?("event_") || k.start_with?("events_") || k == :c  }.transform_keys { |key| "visit_#{key}" }
       search_children = AhoyCaptain.visit.ransack(
         visit_params, context: shared_context
       )
@@ -33,5 +32,11 @@ module AhoyCaptain
 
       joined.where(shared_conditions.reduce(&:and))
     end
+
+    def page_view
+      @query = @query.page_view
+
+      self
+    end
   end
 end

data/app/queries/ahoy_captain/stats/average_views_per_visit_query.rb

@@ -1,12 +1,19 @@
 module AhoyCaptain
   module Stats
     # pls fix
-    class AverageViewsPerVisitQuery < ApplicationQuery
+    class AverageViewsPerVisitQuery < BaseQuery
       def build
-        event_query.joins(:visit)
-                              .where(name: "$view")
-                              .group("ahoy_visits.id")
+        subquery = event_query.select("count(ahoy_events.visit_id) as count").where(name: "$view").group(:visit_id)
 
+        AhoyCaptain.event.select("count").from("(#{subquery.to_sql}) as events")
+      end
+
+      def self.cast_type(_column)
+        nil
+      end
+
+      def self.cast_value(_, value)
+        value.to_i
       end
     end
   end

data/app/queries/ahoy_captain/stats/average_visit_duration_query.rb

@@ -1,11 +1,23 @@
 module AhoyCaptain
   module Stats
-    class AverageVisitDurationQuery < ApplicationQuery
+    class AverageVisitDurationQuery < BaseQuery
       def build
         max_events = event_query.select("#{AhoyCaptain.event.table_name}.visit_id, max(#{AhoyCaptain.event.table_name}.time) as created_at").group("visit_id")
-        visit_query.select("avg((max_events.created_at - #{AhoyCaptain.visit.table_name}.started_at)) as average_visit_duration")
+        visit_query.select("avg((max_events.created_at - #{AhoyCaptain.visit.table_name}.started_at))::interval as average_visit_duration")
                    .joins("LEFT JOIN (#{max_events.to_sql}) as max_events ON #{AhoyCaptain.visit.table_name}.id = max_events.visit_id")
       end
+
+      def self.cast_type(value)
+        ActiveRecord::Type.lookup(:string)
+      end
+
+      def self.cast_value(_type, value)
+        if value.present?
+          ActiveSupport::Duration.parse(value)
+        else
+          ActiveSupport::Duration.parse("P0MT0S")
+        end
+      end
     end
   end
 end

data/app/queries/ahoy_captain/stats/base_query.rb

@@ -0,0 +1,18 @@
+module AhoyCaptain
+  module Stats
+    class BaseQuery < ApplicationQuery
+      include ComparableQuery
+      include LazyComparableQuery
+
+      protected
+
+      def self.cast_type(column)
+        ActiveRecord::Type.lookup(::Ahoy::Visit.columns_hash[column.to_s].type)
+      end
+
+      def self.cast_value(type, value)
+        type.cast(value)
+      end
+    end
+  end
+end

data/app/queries/ahoy_captain/stats/bounce_rates_query.rb

@@ -1,6 +1,6 @@
 module AhoyCaptain
   module Stats
-    class BounceRatesQuery < ApplicationQuery
+    class BounceRatesQuery < BaseQuery
       def build
         total_visits = visit_query.select("date(#{AhoyCaptain.visit.table_name}.started_at) as date, count(*) as count").group("date(#{AhoyCaptain.visit.table_name}.started_at)")
         subquery = visit_query.select(:id, :started_at).joins(:events).group("#{AhoyCaptain.visit.table_name}.id, #{AhoyCaptain.visit.table_name}.started_at").having("count(#{AhoyCaptain.event.table_name}.id) = 1")
@@ -12,6 +12,20 @@ module AhoyCaptain
         ::Ahoy::Visit.with(total_visits: total_visits, single_page_visits: single_page_visits, daily_bounce_rate: daily_bounce_rate).select("bounce_rate, date").from("daily_bounce_rate")
       end
 
+      protected
+
+      def self.cast_type(column)
+        ActiveRecord::Type.lookup(:decimal)
+      end
+
+      def self.cast_value(type, value)
+        if value.blank?
+          return 0.to_d
+        end
+
+        super.round(2)
+      end
+
     end
   end
 end

data/app/queries/ahoy_captain/stats/total_pageviews_query.rb

@@ -1,8 +1,8 @@
 module AhoyCaptain
   module Stats
-    class TotalPageviewsQuery < ApplicationQuery
+    class TotalPageviewsQuery < BaseQuery
       def build
-        event_query.where(name: AhoyCaptain.config.event[:view_name])
+        event_query.page_view
       end
     end
   end

data/app/queries/ahoy_captain/stats/total_visitors_query.rb

@@ -1,6 +1,6 @@
 module AhoyCaptain
   module Stats
-    class TotalVisitorsQuery < ApplicationQuery
+    class TotalVisitorsQuery < BaseQuery
       def build
         visit_query.distinct.select(:id)
       end

data/app/queries/ahoy_captain/stats/unique_visitors_query.rb

@@ -1,6 +1,6 @@
 module AhoyCaptain
   module Stats
-    class UniqueVisitorsQuery < ApplicationQuery
+    class UniqueVisitorsQuery < BaseQuery
       def build
         visit_query.distinct.select(:visitor_token)
       end

data/app/queries/ahoy_captain/stats/views_per_visit_query.rb

@@ -1,6 +1,6 @@
 module AhoyCaptain
   module Stats
-    class ViewsPerVisitQuery < ApplicationQuery
+    class ViewsPerVisitQuery < BaseQuery
       def build
         events = event_query
                    .joins(:visit)

data/app/queries/ahoy_captain/stats/visit_duration_query.rb

@@ -1,15 +1,15 @@
 module AhoyCaptain
   module Stats
-    class VisitDurationQuery < ApplicationQuery
+    class VisitDurationQuery < BaseQuery
       def build
         events = event_query
                    .reselect("max(#{AhoyCaptain.event.table_name}.time) - min(#{AhoyCaptain.event.table_name}.time) as duration, #{AhoyCaptain.event.table_name}.visit_id")
                    .group("#{AhoyCaptain.event.table_name}.visit_id")
 
         ::Ahoy::Visit
-          .select("duration as duration, started_at")
+          .select("duration::duration as duration, started_at")
           .from(events, :views_per_visit_table)
-          .joins("inner join #{AhoyCaptain.visit.table_name} on ahoy_visits.id = views_per_visit_table.visit_id")
+          .joins("inner join #{AhoyCaptain.visit.table_name} on #{AhoyCaptain.visit.table_name}.id = views_per_visit_table.visit_id")
       end
     end
   end