ahoy_captain 0.1.0 → 0.8

data/app/controllers/ahoy_captain/application_controller.rb

@@ -0,0 +1,86 @@
+
+
+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
+
+  class ApplicationController < ActionController::Base
+    include Pagy::Backend
+
+    layout 'ahoy_captain/layouts/application'
+
+    before_action do
+      Current.request = self
+    end
+
+    # show the details frame
+    before_action do
+      if request.headers['Turbo-Frame'] == 'details'
+        request.variant = :details
+      end
+    end
+
+    # act like an spa without being an spa
+    before_action do
+      if request.format.html? && request.headers['Turbo-Frame'].blank?
+        if request.path != root_path
+          requested_params = Rails.application.routes.recognize_path(request.path).except(:controller, :action)
+          params.merge!(requested_params)
+          unless params[:debug]
+            render template: 'ahoy_captain/roots/show'
+          end
+        end
+      end
+    end
+
+    rescue_from Widget::WidgetDisabled do |e|
+      render template: 'ahoy_captain/shared/widget_disabled', locals: { frame: e.frame }
+    end
+
+    private
+
+    def visit_query
+      VisitQuery.call(params)
+    end
+
+    def event_query
+      EventQuery.call(params)
+    end
+
+    def paginate(collection)
+      if paginate?
+        pagy, results = pagy(collection, page: params[:page])
+        @pagination = pagy
+        return results
+      end
+
+      collection
+    end
+
+    def paginate?
+      request.variant.include?(:details)
+    end
+
+    def cached(*names)
+      if AhoyCaptain.cache.class == ActiveSupport::Cache::NullStore
+        return yield
+      end
+      AhoyCaptain.cache.fetch("ahoy_captain:#{names.join(":")}:#{request.query_parameters.sort.map { |k,v| "#{k}-#{v}" }.join(":")}", expire_in: AhoyCaptain.config.cache[:ttl]) do
+        yield
+      end
+    end
+  end
+end

data/app/controllers/ahoy_captain/campaigns_controller.rb

@@ -0,0 +1,27 @@
+module AhoyCaptain
+  class CampaignsController < ApplicationController
+    include Limitable
+
+    before_action do
+      if Widget.disabled?(:campaigns, params[:campaigns_type])
+        raise Widget::WidgetDisabled.new("Widget disabled", :sources)
+      end
+    end
+
+    def index
+      results = cached(:campaigns, params[:campaigns_type]) do
+        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"))
+                   .limit(limit)
+      end
+      @campaigns = paginate(results).map { |campaign| CampaignDecorator.new(campaign) }
+      @campaign_type = params[:campaigns_type]&.titleize&.gsub("Utm", "UTM")
+    end
+  end
+end

data/app/controllers/ahoy_captain/cities_controller.rb

@@ -0,0 +1,24 @@
+module AhoyCaptain
+  class CitiesController < ApplicationController
+    include AhoyCaptain::Limitable
+
+    before_action do
+      if Widget.disabled?(:locations, :cities)
+        raise Widget::WidgetDisabled.new("Widget disabled", :geography)
+      end
+    end
+
+    def index
+      results = cached(:cities) do
+        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")
+          .limit(limit)
+      end
+
+      @cities = paginate(results).map { |city| CityDecorator.new(city) }
+    end
+  end
+end

data/app/controllers/ahoy_captain/countries_controller.rb

@@ -0,0 +1,24 @@
+module AhoyCaptain
+  class CountriesController < ApplicationController
+    include Limitable
+    include Rangeable
+
+    before_action do
+      if Widget.disabled?(:locations, :countries)
+        raise Widget::WidgetDisabled.new("Widget disabled", :geography)
+      end
+    end
+
+    def index
+      results = cached(:countries) do
+        visit_query
+          .reselect("country as label, count(country) as count, sum(count(country)) OVER() as total_count")
+          .group("country")
+          .order("count(country) desc")
+          .limit(limit)
+      end
+
+      @countries = paginate(results).map { |country| CountryDecorator.new(country) }
+    end
+  end
+end

data/app/controllers/ahoy_captain/devices_controller.rb

@@ -0,0 +1,23 @@
+module AhoyCaptain
+  class DevicesController < ApplicationController
+    include Limitable
+
+    before_action do
+      if Widget.disabled?(:devices, params[:devices_type])
+        raise Widget::WidgetDisabled.new("Widget disabled", :devices)
+      end
+    end
+
+    def index
+      results = cached(:devices, params[:devices_type]) do
+          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")
+          .limit(limit)
+      end
+
+      @devices = results.map { |device| DeviceDecorator.new(device) }
+    end
+  end
+end

data/app/controllers/ahoy_captain/entry_pages_controller.rb

@@ -0,0 +1,21 @@
+module AhoyCaptain
+  class EntryPagesController < ApplicationController
+    include Limitable
+
+    before_action do
+      if Widget.disabled?(:entry_pages)
+        raise Widget::WidgetDisabled.new("Widget disabled", :pages)
+      end
+    end
+
+    def index
+      results = cached(:entry_pages) do
+        EntryPagesQuery.call(params, event_query)
+                      .order(Arel.sql "count(#{AhoyCaptain.config.event[:url_column]}) desc")
+                      .limit(limit)
+      end
+
+      @pages = paginate(results).map { |page| EntryPageDecorator.new(page) }
+    end
+  end
+end

data/app/controllers/ahoy_captain/exit_pages_controller.rb

@@ -0,0 +1,20 @@
+module AhoyCaptain
+  class ExitPagesController < ApplicationController
+    include Limitable
+
+    before_action do
+      if Widget.disabled?(:exit_pages)
+        raise Widget::WidgetDisabled.new("Widget disabled", :pages)
+      end
+    end
+
+    def index
+      results = cached(:exit_pages) do
+        ExitPagesQuery.call(params, event_query)
+                      .order(Arel.sql "count(#{AhoyCaptain.config.event[:url_column]}) desc")
+                              .limit(limit)
+      end
+      @pages = paginate(results).map { |page| ExitPageDecorator.new(page) }
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module AhoyCaptain
+  module Filters
+    class BaseController < ApplicationController
+      include Rangeable
+
+      private
+
+      def serialize(value)
+        { text: value }
+      end
+
+      def visit_query
+        VisitQuery.call(params)
+      end
+    end
+  end
+end

data/app/controllers/ahoy_captain/filters/locations_controller.rb

@@ -0,0 +1,11 @@
+module AhoyCaptain
+  module Filters
+    class LocationsController < BaseController
+      def index
+        query = visit_query.all
+
+        render json: query.select("distinct #{params[:type]}").where.not(params[:type] => nil).group(params[:type]).order(Arel.sql "count(*) desc").limit(50).pluck(params[:type]).map { |city| serialize(city) }
+      end
+    end
+  end
+end

data/app/controllers/ahoy_captain/filters/operating_systems/names_controller.rb

@@ -0,0 +1,13 @@
+module AhoyCaptain
+  module Filters
+    module OperatingSystems
+      class NamesController < BaseController
+        def index
+          query = visit_query.all
+
+          render json: query.select("distinct os").where.not(os: nil).group(:os).order(Arel.sql "count(*) desc").pluck(:os).map { |city| serialize(city) }
+        end
+      end
+    end
+  end
+end

data/app/controllers/ahoy_captain/filters/operating_systems/versions_controller.rb

@@ -0,0 +1,13 @@
+module AhoyCaptain
+  module Filters
+    module OperatingSystems
+      class VersionsController < BaseController
+        def index
+          query = visit_query.all
+
+          render json: query.select("distinct os_version").where.not(os_version: nil).group(:os_version).order(Arel.sql "count(*) desc").pluck(:os_version).map { |city| serialize(city) }
+        end
+      end
+    end
+  end
+end

data/app/controllers/ahoy_captain/filters/pages/actions_controller.rb

@@ -0,0 +1,13 @@
+module AhoyCaptain
+  module Filters
+    module Pages
+      class ActionsController < BaseController
+        def index
+          query = event_query.all.with_url.distinct_url
+
+          render json: query.map { |row| { text: row.url } }
+        end
+      end
+    end
+  end
+end

data/app/controllers/ahoy_captain/filters/pages/entry_pages_controller.rb

@@ -0,0 +1,14 @@
+module AhoyCaptain
+  module Filters
+    module Pages
+      # TODO: ACCOMODATE EXIT_PAGES
+      class EntryPagesController < BaseController
+        def index
+          query = event_query.all.with_url.distinct_url
+          render json: query.map { |row| { text: row.url } }
+        end
+
+      end
+    end
+  end
+end

data/app/controllers/ahoy_captain/filters/pages/exit_pages_controller.rb

@@ -0,0 +1,16 @@
+module AhoyCaptain
+  module Filters
+    module Pages
+      # TODO: ACCOMODATE ENTRY_PAGES
+      class ExitPagesController < BaseController
+        def index
+          query = event_query.with_url.distinct_url
+
+          render json: query.map { |row| { text: row.url } }
+        end
+
+      end
+    end
+  end
+
+end

data/app/controllers/ahoy_captain/filters/screens_controller.rb

@@ -0,0 +1,11 @@
+module AhoyCaptain
+  module Filters
+    class ScreensController < BaseController
+      def index
+        query = visit_query.all
+
+        render json: query.select("distinct device_type").where.not(device_type: nil).group(:device_type).order(Arel.sql "count(*) desc").pluck(:device_type).map { |city| serialize(city) }
+      end
+    end
+  end
+end

data/app/controllers/ahoy_captain/filters/sources_controller.rb

@@ -0,0 +1,11 @@
+module AhoyCaptain
+  module Filters
+    class SourcesController < BaseController
+      def index
+        query = visit_query.all
+
+        render json: query.result.select("distinct referring_domain").where.not(referring_domain: nil).group(:referring_domain).order(Arel.sql "count(*) desc").pluck(:referring_domain).map { |city| serialize(city) }
+      end
+    end
+  end
+end

data/app/controllers/ahoy_captain/filters/utms_controller.rb

@@ -0,0 +1,10 @@
+module AhoyCaptain
+  module Filters
+    class UtmsController < BaseController
+      def index
+        query = visit_query.select("#{params[:type]}", "count(#{params[:type]}) as total").group(params[:type]).order(Arel.sql "count(#{params[:type]}) desc").pluck(params[:type]).map { |city| serialize(city || "Direct/none") }
+        render json: query
+      end
+    end
+  end
+end

data/app/controllers/ahoy_captain/funnels_controller.rb

@@ -0,0 +1,8 @@
+module AhoyCaptain
+  class FunnelsController < ApplicationController
+    def show
+      funnel = AhoyCaptain.configuration.funnels[params[:id]]
+      @funnel = FunnelPresenter.new(funnel, event_query).build
+    end
+  end
+end

data/app/controllers/ahoy_captain/goals_controller.rb

@@ -0,0 +1,7 @@
+module AhoyCaptain
+  class GoalsController < ApplicationController
+    def index
+      @presenter = GoalsPresenter.new(event_query).build
+    end
+  end
+end

data/app/controllers/ahoy_captain/realtimes_controller.rb

@@ -0,0 +1,7 @@
+module AhoyCaptain
+  class RealtimesController < ApplicationController
+    def show
+      @total = event_query.where("#{AhoyCaptain.event.table_name}.time > ?", 1.minute.ago).distinct(:visit_id).count(:visit_id)
+    end
+  end
+end

data/app/controllers/ahoy_captain/regions_controller.rb

@@ -0,0 +1,24 @@
+module AhoyCaptain
+  class RegionsController < ApplicationController
+    include Limitable
+
+    before_action do
+      if Widget.disabled?(:locations, :regions)
+        raise Widget::WidgetDisabled.new("Widget disabled", :geography)
+      end
+    end
+
+    def index
+      results = cached(:regions) do
+        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")
+          .limit(limit)
+      end
+
+      @regions = paginate(results).map { |region| RegionDecorator.new(region) }
+    end
+  end
+end

data/app/controllers/ahoy_captain/roots_controller.rb

@@ -0,0 +1,6 @@
+module AhoyCaptain
+  class RootsController < ApplicationController
+    def show
+    end
+  end
+end

data/app/controllers/ahoy_captain/sources_controller.rb

@@ -0,0 +1,24 @@
+module AhoyCaptain
+  class SourcesController < ApplicationController
+    include Limitable
+
+    before_action do
+      if Widget.disabled?(:sources)
+        raise Widget::WidgetDisabled.new("Widget disabled", :sources)
+      end
+    end
+
+    def index
+      results = cached(:sources) do
+        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")
+                   .limit(limit)
+      end
+
+      @sources = paginate(results).map { |source| AhoyCaptain::SourceDecorator.new(source) }
+    end
+  end
+
+end

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

@@ -0,0 +1,67 @@
+module AhoyCaptain
+  module Stats
+    class BaseController < ApplicationController
+      include Rangeable
+
+      INTERVAL_PERIOD = {
+        "realtime" => ["minute"],
+        "day" => ["minute", "hour"],
+        "7d" => ["hour", "day"],
+        "month" => ["day", "week"],
+        "all" => ["day", "week", "month"]
+      }
+
+      INTERVALS = ["minute", "hour", "day", "week", "month"]
+      private
+
+      helper_method :selected_interval
+      def selected_interval
+        if params[:interval].in?(INTERVALS)
+          params[:interval]
+        else
+          default_interval_for_period
+        end
+      end
+
+      def default_interval_for_period
+        default_interval_for_date_range(range)
+      end
+
+      def default_interval_for_date_range(range)
+        if range[1].nil?
+          # assume we're in a realtime
+          return INTERVAL_PERIOD["realtime"][0]
+        end
+        diff = (range[1] - range[0]).seconds
+        if diff.in_months > 1
+          "month"
+        elsif diff.in_days > 0
+          "day"
+        else
+          "hour"
+        end
+      end
+
+      helper_method :available_intervals
+      def available_intervals
+        if range
+          return INTERVAL_PERIOD["realtime"] if range[1].nil?
+
+          diff = (range[1] - range[0]).seconds.in_days
+
+          if diff == 0
+            INTERVAL_PERIOD["day"]
+          elsif diff <= 7
+            INTERVAL_PERIOD["7d"]
+          elsif diff <= 31
+            INTERVAL_PERIOD["month"]
+          else
+            INTERVAL_PERIOD["all"]
+          end
+        else
+          INTERVAL_PERIOD["month"]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module AhoyCaptain
+  module Stats
+    class BounceRatesController < BaseController
+      # @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")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module AhoyCaptain
+  module Stats
+    class TotalPageviewsController < BaseController
+      def index
+        @stats = AhoyCaptain::Stats::TotalPageviewsQuery.call(params).group_by_period(selected_interval, :time).count
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module AhoyCaptain
+  module Stats
+    class TotalVisitsController < BaseController
+      def index
+        @stats = AhoyCaptain::Stats::TotalVisitorsQuery.call(params).group_by_period(selected_interval, :started_at).count
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module AhoyCaptain
+  module Stats
+    class UniqueVisitorsController < BaseController
+      def index
+        @stats = AhoyCaptain::Stats::UniqueVisitorsQuery.call(params).group_by_period(selected_interval, :started_at).count
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module AhoyCaptain
+  module Stats
+    class ViewsPerVisitsController < BaseController
+      include Rangeable
+
+      # @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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module AhoyCaptain
+  module Stats
+    class VisitDurationsController < BaseController
+      def index
+        @stats = AhoyCaptain::Stats::VisitDurationQuery.call(params).group_by_period(selected_interval, 'started_at').average(:duration)
+      end
+    end
+  end
+end

data/app/controllers/ahoy_captain/stats_controller.rb

@@ -0,0 +1,7 @@
+module AhoyCaptain
+  class StatsController < ApplicationController
+    def show
+      @presenter = DashboardPresenter.new(params)
+    end
+  end
+end

data/app/controllers/ahoy_captain/top_pages_controller.rb

@@ -0,0 +1,26 @@
+module AhoyCaptain
+  class TopPagesController < ApplicationController
+    include Limitable
+
+    before_action do
+      if Widget.disabled?(:top_pages)
+        raise Widget::WidgetDisabled.new("Widget disabled", :pages)
+      end
+    end
+
+    def index
+      results = cached(:top_pages) do
+        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"))
+                   .limit(limit)
+      end
+
+      @pages = paginate(results).map { |page| TopPageDecorator.new(page) }
+    end
+  end
+end