ahoy_captain 0.9 → 0.10.0

data/app/models/ahoy_captain/range_from_params.rb

@@ -0,0 +1,75 @@
+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 [](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/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

data/app/queries/ahoy_captain/visit_query.rb

@@ -1,6 +1,5 @@
 module AhoyCaptain
   class VisitQuery < ApplicationQuery
-    include Rangeable
 
     def build
       shared_context = Ransack::Context.for(AhoyCaptain.visit)
@@ -9,7 +8,7 @@ module AhoyCaptain
         ransack_params_for(:visit).reject { |k,v| k.start_with?("events_") }, context: shared_context
       )
       search_children = AhoyCaptain.event.ransack(
-        ransack_params_for(:event).reject { |k,v| k.start_with?("visit_") }.transform_keys { |key| "events_#{key}" }, context: shared_context
+        ransack_params_for(:event).reject { |k,v| k.start_with?("visit_") || k == :c }.transform_keys { |key| "events_#{key}" }, context: shared_context
       )
 
       shared_conditions = [search_parents, search_children].map { |search|

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

@@ -0,0 +1,25 @@
+module AhoyCaptain
+  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'