ahoy_captain 0.8 → 0.10.0

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,76 +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)
-          (result.values.sum.to_f / result.size).round(2)
-        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
 
@@ -53,6 +54,7 @@ module AhoyCaptain
       EventQuery.call(params)
     end
 
+    # this could be better
     def ransack_params_for(type)
       ransackable_params = {}
 
@@ -61,12 +63,13 @@ module AhoyCaptain
           visit: (AhoyCaptain.visit.ransackable_attributes + AhoyCaptain.visit.ransackable_scopes).map(&:to_s),
           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)
+          if type == :event && (ransackable_attributes[:visit].include?(attribute_name) || ransackable_attributes[:visit].include?(key))
             ransackable_params["visit_#{key}"] = value
-          elsif type == :visit && ransackable_attributes[:event].include?(attribute_name) || ransackable_attributes[:event].include?(key)
+          elsif type == :visit && (ransackable_attributes[:event].include?(attribute_name) || ransackable_attributes[:event].include?(key))
             ransackable_params["events_#{key}"] = value
           else
             ransackable_params[key] = value
@@ -74,36 +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
@@ -117,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/campaign_query.rb

@@ -0,0 +1,14 @@
+module AhoyCaptain
+  class CampaignQuery < ApplicationQuery
+    def build
+      visit_query
+        .select(
+          "COALESCE(#{params[:campaigns_type]}, 'Direct/None') as label",
+          "count(COALESCE(#{params[:campaigns_type]}, 'Direct/None')) as count",
+          "sum(count(COALESCE(#{params[:campaigns_type]}, 'Direct/None'))) OVER() as total_count"
+        )
+        .group("COALESCE(#{params[:campaigns_type]}, 'Direct/None')")
+        .order(Arel.sql("count(COALESCE(#{params[:campaigns_type]}, 'Direct/None')) desc"))
+    end
+  end
+end

data/app/queries/ahoy_captain/city_query.rb

@@ -0,0 +1,11 @@
+module AhoyCaptain
+  class CityQuery < ApplicationQuery
+    def build
+      visit_query
+        .select("city, country, count(concat(city, region, country)) as count, sum(count(concat(city, region, country))) over() as total_count")
+        .where.not(city: nil)
+        .group("city, region, country")
+        .order(Arel.sql "count(concat(city, region, country)) desc")
+    end
+  end
+end

data/app/queries/ahoy_captain/country_query.rb

@@ -0,0 +1,10 @@
+module AhoyCaptain
+  class CountryQuery < ApplicationQuery
+    def build
+      visit_query
+        .reselect("country as label, count(country) as count, sum(count(country)) OVER() as total_count")
+        .group("country")
+        .order("count(country) desc")
+    end
+  end
+end

data/app/queries/ahoy_captain/device_query.rb

@@ -0,0 +1,10 @@
+module AhoyCaptain
+  class DeviceQuery < ApplicationQuery
+    def build
+      visit_query
+        .select("#{params[:devices_type]} as label", "count(#{params[:devices_type]}) as count", "sum(count(#{params[:devices_type]})) over() as total_count")
+        .group(params[:devices_type])
+        .order("count(#{params[:devices_type]}) desc")
+    end
+  end
+end

data/app/queries/ahoy_captain/entry_pages_query.rb

@@ -2,14 +2,15 @@ module AhoyCaptain
   class EntryPagesQuery < ApplicationQuery
 
     def build
-      max_id_query = @query.with_routes.select("min(#{AhoyCaptain.event.table_name}.id) as id").group("visit_id")
-      @query = @query.with_routes.select(
+      max_id_query = event_query.with_routes.select("min(#{AhoyCaptain.event.table_name}.id) as id").group("visit_id")
+      event_query.with_routes.select(
         "#{AhoyCaptain.config.event[:url_column]} as url",
         "count(#{AhoyCaptain.config.event[:url_column]}) as count",
         "sum(count(#{AhoyCaptain.config.event[:url_column]})) over() as total_count"
       )
                      .where(id: max_id_query)
                      .group(AhoyCaptain.config.event[:url_column])
+                     .order(Arel.sql "count(#{AhoyCaptain.config.event[:url_column]}) desc")
     end
 
 

data/app/queries/ahoy_captain/event_query.rb

@@ -1,35 +1,42 @@
 module AhoyCaptain
   class EventQuery < ApplicationQuery
-    include Rangeable
 
     def build
-      shared_context = Ransack::Context.for(AhoyCaptain.event)
+      entry_pages = ransack_params_for(:event).select { |k,v| k.start_with?("entry_page") }
+      exit_pages = ransack_params_for(:event).select { |k,v| k.start_with?("exit_page") }
 
-      search_parents = AhoyCaptain.event.ransack(
+      event = AhoyCaptain.event
+      shared_context = Ransack::Context.for(event)
+
+      search_parents = event.ransack(
         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_") || k == :c  }.transform_keys { |key| "visit_#{key}" }
       search_children = AhoyCaptain.visit.ransack(
-        ransack_params_for(:visit).reject { |k,v| k.start_with?("event_") }.transform_keys { |key| "visit_#{key}" }, context: shared_context
+        visit_params, context: shared_context
       )
-
       shared_conditions = [search_parents, search_children].map { |search|
         Ransack::Visitor.new.accept(search.base)
       }
 
-      AhoyCaptain.event.joins(shared_context.join_sources)
-                 .where(shared_conditions.reduce(&:or))
+      joined = AhoyCaptain.event.joins(shared_context.join_sources)
 
-    end
+      if entry_pages.values.any?(&:present?) || params[:controller].include?("entry_pages")
+        joined = joined.with_entry_pages
+      end
 
-    def within_range
-      self
+      if exit_pages.values.any?(&:present?) || params[:controller].include?("exit_pages")
+        joined = joined.with_exit_pages
+      end
+
+      joined.where(shared_conditions.reduce(&:and))
     end
 
-    def with_visit
-      @query = @query.joins(:visit)
+    def page_view
+      @query = @query.page_view
 
       self
     end
-
   end
 end

data/app/queries/ahoy_captain/exit_pages_query.rb

@@ -2,14 +2,16 @@ module AhoyCaptain
   class ExitPagesQuery < ApplicationQuery
 
     def build
-      max_id_query = @query.with_routes.select("max(#{AhoyCaptain.event.table_name}.id) as id").group("visit_id")
-      @query = @query.with_routes.select(
+      max_id_query = event_query.with_routes.select("max(#{AhoyCaptain.event.table_name}.id) as id").group("visit_id")
+      event_query.with_routes.select(
         "#{AhoyCaptain.config.event[:url_column]} as url",
         "count(#{AhoyCaptain.config.event[:url_column]}) as count",
         "sum(count(#{AhoyCaptain.config.event[:url_column]})) over() as total_count"
       )
-                     .where(id: max_id_query)
-                     .group(AhoyCaptain.config.event[:url_column])
+                 .where(id: max_id_query)
+                 .group(AhoyCaptain.config.event[:url_column])
+                 .order(Arel.sql "count(#{AhoyCaptain.config.event[:url_column]}) desc")
+
     end
 
 

data/app/queries/ahoy_captain/region_query.rb

@@ -0,0 +1,11 @@
+module AhoyCaptain
+  class RegionQuery < ApplicationQuery
+    def build
+      visit_query
+        .reselect("region, country, count(concat(region, country)) as count, sum(count(region)) over() as total_count")
+        .where.not(region: nil)
+        .group("region, country")
+        .order(Arel.sql "count(concat(region, country)) desc")
+    end
+  end
+end

data/app/queries/ahoy_captain/source_query.rb

@@ -0,0 +1,10 @@
+module AhoyCaptain
+  class SourceQuery < ApplicationQuery
+    def build
+      visit_query.select("substring(referring_domain from '(?:.*://)?(?:www\.)?([^/?]*)') as referring_domain, count(substring(referring_domain from '(?:.*://)?(?:www\.)?([^/?]*)')) as count, sum(count(substring(referring_domain from '(?:.*://)?(?:www\.)?([^/?]*)'))) OVER() as total_count")
+                 .where.not(referring_domain: nil)
+                 .group("substring(referring_domain from '(?:.*://)?(?:www\.)?([^/?]*)')")
+                 .order(Arel.sql "count(substring(referring_domain from '(?:.*://)?(?:www\.)?([^/?]*)')) desc")
+    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/top_page_query.rb

@@ -0,0 +1,13 @@
+module AhoyCaptain
+  class TopPageQuery < ApplicationQuery
+    def build
+      event_query.with_routes
+                 .select(
+        "#{AhoyCaptain.config.event[:url_column]} as url",
+        "count(*) as count",
+        "sum(count(*)) over() as total_count"
+      ).group(Arel.sql ("(#{AhoyCaptain.config.event[:url_column]})"))
+                 .order(Arel.sql("count(#{AhoyCaptain.config.event[:url_column]}) desc"))
+    end
+  end
+end