ahoy_captain 0.77 → 0.81

data/app/decorators/ahoy_captain/region_decorator.rb

@@ -1,10 +1,26 @@
 module AhoyCaptain
   class RegionDecorator < CountryDecorator
+    def self.csv_map(params = {})
+      {
+        "Country" => :country,
+        "Region" => :region,
+        "Total" => :unit_amount
+      }
+    end
+
     def display_name
       search = search_query(region_eq: object.region, country_eq: object.country)
       frame_link("#{country_emoji(object.country)} #{object.region}", search)
     end
 
+    def country
+      "#{country_emoji(object.country)} #{object.country}"
+    end
+
+    def region
+      object.region
+    end
+
     def unit_amount
       object.count
     end

data/app/decorators/ahoy_captain/source_decorator.rb

@@ -1,5 +1,12 @@
 module AhoyCaptain
   class SourceDecorator < ApplicationDecorator
+    def self.csv_map(params = {})
+      {
+        "Domain" => :referring_domain,
+        "Total" => :unit_amount
+      }
+    end
+
     def display_name
       display = %Q(
         <div class='flex justify-start space-x-8 col-span-1 items-center'>

data/app/models/ahoy_captain/export.rb

@@ -0,0 +1,48 @@
+module AhoyCaptain
+  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/presenters/ahoy_captain/dashboard_presenter.rb

@@ -10,27 +10,32 @@ module AhoyCaptain
 
     def unique_visitors
       cached(:unique_visitors) do
-        Stats::UniqueVisitorsQuery.call(params).count(:ip)
+        Stats::UniqueVisitorsQuery.call(params).count(:visitor_token)
       end
     end
 
     def total_visits
       cached(:total_visits) do
-        Stats::TotalVisitorsQuery.call(params).count
+        Stats::TotalVisitorsQuery.call(params).count(:id)
       end
     end
 
     def total_pageviews
       cached(:total_pageviews) do
-        Stats::TotalPageviewsQuery.call(params).count
+        Stats::TotalPageviewsQuery.call(params).count(:id)
       end
     end
 
     def views_per_visit
       cached(:views_per_visit) do
         begin
-          result = Stats::AverageViewsPerVisitQuery.call(params).count
-          (result.values.sum.to_f / result.size).round(2)
+          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"
@@ -39,23 +44,26 @@ module AhoyCaptain
           end
         end
       end
-
     end
 
     def bounce_rate
       cached(:bounce_rate) do
         begin
-        result = Stats::BounceRatesQuery.call(params)
-        result[0].bounce_rate.round(2)
+          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
+          if e.message.include?("PG::DivisionByZero")
+            return "0"
+          else
+            raise e
+          end
         end
       end
-
-      end
     end
 
     def visit_duration
@@ -63,7 +71,7 @@ module AhoyCaptain
         result = Stats::AverageVisitDurationQuery.call(params)
         duration = result[0].average_visit_duration
         if duration
-          "#{duration.parts[:minutes]}M #{duration.parts[:seconds].round}S"
+          "#{duration.in_minutes.to_i}M #{duration.parts[:seconds].to_i}S"
         else
           "0M 0S"
         end
@@ -73,7 +81,7 @@ module AhoyCaptain
     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
+      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
     end

data/app/presenters/ahoy_captain/funnel_presenter.rb

@@ -9,44 +9,47 @@ module AhoyCaptain
     end
 
     def build
-      queries = {}
-      prev_goal = nil
-      prev_table = nil
-      selects = []
-      @funnel.goals.each do |goal|
-        if prev_goal
-          query = ::Ahoy::Event
-                    .select("distinct ahoy_events.visit_id")
-                    .from(prev_table.to_s)
-                    .joins("inner join ahoy_events on ahoy_events.visit_id = #{prev_table}.id")
-                    .where("ahoy_events.name = ?", goal.event_name.to_s).to_sql
-          prev_table = "#{goal.id}"
-          selects << ["SELECT '#{prev_goal.title} > #{goal.title}' as step, count(*) from #{prev_table}"]
-          queries[prev_table] = query
-        else
-          prev_table = :visitors
-          prev_goal = goal
+      if AhoyCaptain.config.goals.none?
+        @goals = []
+        return self
+      end
 
-          query = @event_query
-                    .select("distinct(visit_id) as id, min(time) as min_time")
-                    .where(name: goal.event_name.to_s)
-                    .group("1").to_sql
-          selects << ["'#{goal.title}' as step, count(*) from #{prev_table}"]
+      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 from totals"]
+      last_goal = nil
+      map = {}.with_indifferent_access
 
-          queries[prev_table] = query
-        end
+      AhoyCaptain.config.goals.each_with_index do |goal, index|
+        queries[goal.id] = @event_query.select("count(distinct(#{AhoyCaptain.event.table_name}.visit_id)) as unique_visits, '#{goal.id}' as name, count(distinct #{AhoyCaptain.event.table_name}.id) as total_events, #{index + 1} as sort_order").merge(goal.event_query.call).group("#{AhoyCaptain.event.table_name}.name")
+        selects << ["SELECT unique_visits, name, total_events, sort_order from #{goal.id}"]
+        map[goal.id] = goal
+        last_goal = goal
       end
 
-      select = selects.join(" UNION ").delete_suffix(" from #{prev_table}")
-
+      # 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(prev_table).order("count desc")
+        queries,
+        ).select(select).from("#{last_goal.id}").order("sort_order asc")
+
+      items = ::Ahoy::Event.with(steps: steps).select("total_events, unique_visits, name, round((total_events::numeric/lag(total_events, 1) over ()),2) as drop_off").from("steps").order("sort_order asc").index_by(&:name)
+      items.delete("_internal_total_visits_")
+      @steps = []
 
-      @steps = ::Ahoy::Event.with(steps: steps).select("step, count, lag(count, 1) over () as lag, abs(count::numeric - lag(count, 1) over ())::integer as drop_off, round((1.0 - count::numeric/GREATEST(lag(count, 1) over (), 1)),2) as conversion_rate").from("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

data/app/presenters/ahoy_captain/goals_presenter.rb

@@ -6,44 +6,53 @@ module AhoyCaptain
       @goals = nil
     end
 
+    # this is a dumpster fire
     def build
       if AhoyCaptain.config.goals.none?
         @goals = []
         return self
       end
-      queries = {}
-      selects = []
+
+      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"]
       last_goal = nil
-      map = {}
-      AhoyCaptain.config.goals.each do |goal|
-        queries[goal.id] = @event_query.select("count(distinct(visit_id)) as uniques, count(name) as total, name").where(name: goal.event_name).group("name")
-        selects << ["SELECT total, uniques, name from #{goal.id}"]
-        map[goal.event_name] = goal
+      map = {}.with_indifferent_access
+
+      AhoyCaptain.config.goals.each_with_index do |goal, index|
+        queries[goal.id] = @event_query.select(
+          [
+            "count(distinct(#{AhoyCaptain.event.table_name}.visit_id)) as unique_visits" ,
+            "'#{goal.id}' as name",
+            "count(distinct #{AhoyCaptain.event.table_name}.id) as total_events",
+            "#{index + 1} as sort_order",
+          ]
+        ).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}"]
+        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}")
-
-      items = ::Ahoy::Event.with(steps: steps).select("total, uniques, name, 0 as conversion_rate").from("steps").index_by(&:name)
-      @goals = []
-      map.each do |name, _|
-        if items[name]
-          items[name].name = map[name].title
-          items[name].conversion_rate = ((items[name].total / total.to_d) * 100).round(2) * 100
-          @goals << items[name]
-        else
-          @goals << OpenStruct.new(name: map[name].title, uniques: 0, total: 0, conversion_rate: 0)
-        end
-      end
+        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
-      @total ||= @event_query.distinct(:visitor_token).count
+    def total_visitors
+      @total_visitors ||= @event_query.select(:visit_id).distinct.count
     end
 
     def as_json

data/app/queries/ahoy_captain/application_query.rb

@@ -21,6 +21,9 @@ module AhoyCaptain
       @query = query
     end
 
+    def inspect
+      "<#{self.class.name}>"
+    end
     protected
 
     def build
@@ -90,8 +93,8 @@ module AhoyCaptain
           if range.size == 2
             ransackable_params["started_at_gt"] = range[0]
             ransackable_params["started_at_lt"] = range[1]
-            ransackable_params["events_time_gt"] = range[0]
-            ransackable_params["events_time_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]

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

@@ -3,7 +3,22 @@ module AhoyCaptain
     include Rangeable
 
     def build
-      ::Ahoy::Event.ransack(ransack_params_for(:event)).result
+      shared_context = Ransack::Context.for(AhoyCaptain.event)
+
+      search_parents = AhoyCaptain.event.ransack(
+        ransack_params_for(:event).reject { |k,v| k.start_with?("visit_") }, context: shared_context
+      )
+      search_children = AhoyCaptain.visit.ransack(
+        ransack_params_for(:visit).reject { |k,v| k.start_with?("event_") }.transform_keys { |key| "visit_#{key}" }, 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))
+
     end
 
     def within_range

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_visit_duration_query.rb

@@ -2,13 +2,9 @@ module AhoyCaptain
   module Stats
     class AverageVisitDurationQuery < ApplicationQuery
       def build
-        events = event_query
-                   .reselect("visit_id, max(time) - min(time) as visit_duration")
-                   .group("visit_id")
-
-        ::Ahoy::Visit.joins("INNER JOIN #{::AhoyCaptain.event.table_name} ON #{::AhoyCaptain.event.table_name}.visit_id = visit_durations.visit_id")
-                   .reselect("avg(visit_duration) as average_visit_duration")
-                   .from(events, :visit_durations)
+        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")
+                   .joins("LEFT JOIN (#{max_events.to_sql}) as max_events ON #{AhoyCaptain.visit.table_name}.id = max_events.visit_id")
       end
     end
   end

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

@@ -2,13 +2,16 @@ module AhoyCaptain
   module Stats
     class BounceRatesQuery < ApplicationQuery
       def build
-        ab = event_query.select("visit_id", "count(*) as num_events").group("visit_id")
-        ::Ahoy::Event.with(visit_counts: ab)
-                         .joins("inner join ahoy_events on ahoy_events.visit_id = visit_counts.visit_id ")
-                         .joins(:visit)
-                         .select("LEAST((COUNT(CASE WHEN num_events = 1 THEN 1 ELSE NULL END)::numeric / COUNT(*)), 100) AS bounce_rate")
-                         .from("visit_counts")
+        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")
+        single_page_visits = ::Ahoy::Visit.select("date(subquery.started_at) as date, count(*) as count").from("(#{subquery.to_sql}) as subquery").group("date(started_at)")
+        daily_bounce_rate = ::Ahoy::Visit.select("total_visits.date, (single_page_visits.count::FLOAT / total_visits.count) * 100 as bounce_rate")
+                                         .from("total_visits")
+                                         .joins("join single_page_visits ON total_visits.date = single_page_visits.date")
+
+        ::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
+
     end
   end
 end

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

@@ -2,7 +2,7 @@ module AhoyCaptain
   module Stats
     class TotalVisitorsQuery < ApplicationQuery
       def build
-        visit_query.distinct(:visit_id)
+        visit_query.distinct.select(:id)
       end
     end
   end

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

@@ -2,7 +2,7 @@ module AhoyCaptain
   module Stats
     class UniqueVisitorsQuery < ApplicationQuery
       def build
-        visit_query.distinct(:ip)
+        visit_query.distinct.select(:visitor_token)
       end
     end
   end

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

@@ -4,9 +4,9 @@ module AhoyCaptain
       def build
         events = event_query
                    .joins(:visit)
-                   .select("#{::AhoyCaptain.visit.table_name}.started_at as started_at, count(name) / count(distinct visit_id) as views_per_visit")
+                   .select("#{::AhoyCaptain.visit.table_name}.started_at as started_at, count(#{AhoyCaptain.event.table_name}.name) / count(distinct #{AhoyCaptain.event.table_name}.visit_id) as views_per_visit")
                    .where(name: AhoyCaptain.config.event[:view_name])
-                   .group("started_at, visit_id")
+                   .group("#{AhoyCaptain.visit.table_name}.started_at, #{AhoyCaptain.event.table_name}.visit_id")
 
         ::Ahoy::Visit
                      .select("views_per_visit as views_per_visit")

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

@@ -3,13 +3,13 @@ module AhoyCaptain
     class VisitDurationQuery < ApplicationQuery
       def build
         events = event_query
-                   .select("max(time) - min(time) as duration, visit_id")
-                   .group("visit_id")
+                   .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
-          .joins("inner join ahoy_visits on ahoy_visits.id = views_per_visit_table.visit_id")
-          .select("duration as duration, ahoy_visits.started_at")
+          .select("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")
       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

data/app/queries/ahoy_captain/visit_query.rb

@@ -3,22 +3,22 @@ module AhoyCaptain
     include Rangeable
 
     def build
-      ::Ahoy::Visit.ransack(ransack_params_for(:visit)).result
-    end
+      shared_context = Ransack::Context.for(AhoyCaptain.visit)
 
-    def within_range
-      if range
-        abort
-        @query = @query.where('started_at >= ? and started_at < ?', range[0], range[1])
-      end
+      search_parents = AhoyCaptain.visit.ransack(
+        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
+      )
 
-      self
-    end
+      shared_conditions = [search_parents, search_children].map { |search|
+        Ransack::Visitor.new.accept(search.base)
+      }
 
-    def with_events
-      @query = @query.joins(:events)
+      AhoyCaptain.visit.joins(shared_context.join_sources)
+            .where(shared_conditions.reduce(&:or))
 
-      self
     end
 
     def is_a?(other)