lookout-ahoy 0.1.0

data/app/controllers/lookout/application_controller.rb

@@ -0,0 +1,83 @@
+module Lookout
+  class ApplicationController < ActionController::Base
+    include Pagy::Backend
+    include CompareMode
+    include RangeOptions
+    include Rangeable
+
+    layout 'lookout/layouts/application'
+
+    def period
+      params[:period] || Lookout.config.ranges.default
+    end
+
+    # show the details frame
+    before_action :use_details_frame
+
+    # act like an spa without being an spa
+    before_action :act_like_an_spa
+
+    rescue_from Widget::WidgetDisabled do |e|
+      respond_to do |f|
+        f.turbo_stream do
+          render(partial: "lookout/layouts/shared/widget_disabled", locals: { frame: e.frame })
+        end
+        f.html do
+          render(partial: "lookout/layouts/shared/widget_disabled", locals: { frame: e.frame })
+        end
+      end
+    end
+
+    private
+
+    def use_details_frame
+      if request.headers['Turbo-Frame'] == 'details'
+        request.variant = :details
+      end
+    end
+
+    def act_like_an_spa
+      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: 'lookout/roots/show'
+          end
+        end
+      end
+    end
+
+    def visit_query
+      VisitQuery.call(params)
+    end
+
+    def event_query
+      EventQuery.call(params)
+    end
+
+    # Only paginate details requests requests
+    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 Lookout.cache.class == ActiveSupport::Cache::NullStore
+        return yield
+      end
+      Lookout.cache.fetch("lookout:#{names.join(":")}:#{request.query_parameters.sort.map { |k,v| "#{k}-#{v}" }.join(":")}", expire_in: Lookout.config.cache[:ttl]) do
+        yield
+      end
+    end
+  end
+end

data/app/controllers/lookout/campaigns_controller.rb

@@ -0,0 +1,19 @@
+module Lookout
+  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
+        CampaignQuery.call(params).limit(limit)
+      end
+      @campaigns = paginate(results).map { |campaign| CampaignDecorator.new(campaign, self) }
+      @campaign_type = params[:campaigns_type]&.titleize&.gsub("Utm", "UTM")
+    end
+  end
+end

data/app/controllers/lookout/devices_controller.rb

@@ -0,0 +1,20 @@
+module Lookout
+  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
+        DeviceQuery.call(params)
+                   .limit(limit)
+      end
+
+      @devices = results.map { |device| DeviceDecorator.new(device, self) }
+    end
+  end
+end

data/app/controllers/lookout/entry_pages_controller.rb

@@ -0,0 +1,19 @@
+module Lookout
+  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).limit(limit)
+      end
+
+      @pages = paginate(results).map { |page| EntryPageDecorator.new(page, self) }
+    end
+  end
+end

data/app/controllers/lookout/exit_pages_controller.rb

@@ -0,0 +1,19 @@
+module Lookout
+  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)
+                      .limit(limit)
+      end
+      @pages = paginate(results).map { |page| ExitPageDecorator.new(page, self) }
+    end
+  end
+end

data/app/controllers/lookout/exports_controller.rb

@@ -0,0 +1,14 @@
+module Lookout
+  class ExportsController < ApplicationController
+    skip_before_action :act_like_an_spa
+
+    def show
+      export = Export.new(params, self).build
+      file = export.to_zip
+      send_data file.read,
+                type: 'application/zip',
+                disposition: 'attachment',
+                filename: "Lookout export #{request.host} #{range[0].to_date} to #{(range[1] || Time.current).to_date}.zip"
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Lookout
+  module Filters
+    class BaseController < ApplicationController
+      private
+
+      def serialize(value)
+        { text: (value.presence || Lookout.none.text), value: (value.presence || Lookout.none.value) }
+      end
+
+      def visit_query
+        VisitQuery.call(params)
+      end
+    end
+  end
+end

data/app/controllers/lookout/filters/goals_controller.rb

@@ -0,0 +1,9 @@
+module Lookout
+  module Filters
+    class GoalsController < BaseController
+      def index
+        render json: Lookout.configuration.goals.map { |goal| { text: goal.title, value: goal.id } }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Lookout
+  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/lookout/filters/operating_systems/names_controller.rb

@@ -0,0 +1,13 @@
+module Lookout
+  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/lookout/filters/operating_systems/versions_controller.rb

@@ -0,0 +1,13 @@
+module Lookout
+  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/lookout/filters/pages/actions_controller.rb

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

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

@@ -0,0 +1,14 @@
+module Lookout
+  module Filters
+    module Pages
+      class EntryPagesController < BaseController
+        def index
+          query = event_query.all.distinct("entry_pages.url").select("entry_pages.url as url")
+
+          render json: query.map { |row| serialize(row.url) }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Lookout
+  module Filters
+    module Pages
+      class ExitPagesController < BaseController
+        def index
+          query = event_query.distinct("exit_pages.url").select("exit_pages.url as url")
+
+          render json: query.map { |row| serialize(row.url) }
+        end
+
+      end
+    end
+  end
+
+end

data/app/controllers/lookout/filters/properties/names_controller.rb

@@ -0,0 +1,29 @@
+module Lookout
+  module Filters
+    module Properties
+      class NamesController < BaseController
+        def index
+          keys = extract_property_keys
+          render json: keys.map { |key| serialize(key) }
+        end
+
+        private
+
+        def extract_property_keys
+          if Lookout::DatabaseAdapter.postgresql?
+            ::Ahoy::Event
+              .select("jsonb_object_keys(properties) as keys")
+              .distinct
+              .pluck("jsonb_object_keys(properties)")
+          else
+            # SQLite: use json_each to extract keys
+            ::Ahoy::Event
+              .from("#{::Ahoy::Event.table_name}, json_each(#{::Ahoy::Event.table_name}.properties)")
+              .select("DISTINCT json_each.key as keys")
+              .pluck("json_each.key")
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/lookout/filters/properties/values_controller.rb

@@ -0,0 +1,15 @@
+module Lookout
+  module Filters
+    module Properties
+      class ValuesController < BaseController
+        def index
+          param_key = params[:q].to_unsafe_h.detect { |k,v| k.ends_with?("_i_cont") && k.starts_with?("properties.") }[0]
+          key = param_key.delete_prefix("properties.").delete_suffix("_i_cont")
+          query = event_query.all.distinct.select("properties->>'#{key}'").pluck(Arel.sql "properties->>'#{key}'")
+
+          render json: query.map { |element| serialize(element) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Lookout
+  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/lookout/filters/sources_controller.rb

@@ -0,0 +1,11 @@
+module Lookout
+  module Filters
+    class SourcesController < BaseController
+      def index
+        query = visit_query.all
+
+        render json: query.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/lookout/filters/utms_controller.rb

@@ -0,0 +1,10 @@
+module Lookout
+  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) }
+        render json: query
+      end
+    end
+  end
+end

data/app/controllers/lookout/funnels_controller.rb

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

data/app/controllers/lookout/goals_controller.rb

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

data/app/controllers/lookout/locations/cities_controller.rb

@@ -0,0 +1,22 @@
+module Lookout
+  module Locations
+    class CitiesController < ApplicationController
+      include Lookout::Limitable
+
+      before_action do
+        if Widget.disabled?(:locations, :cities)
+          raise Widget::WidgetDisabled.new("Widget disabled", :geography)
+        end
+      end
+
+      def index
+        results = cached(:cities) do
+          CityQuery.call(params)
+                   .limit(limit)
+        end
+
+        @cities = paginate(results).map { |city| CityDecorator.new(city, self) }
+      end
+    end
+  end
+end

data/app/controllers/lookout/locations/countries_controller.rb

@@ -0,0 +1,22 @@
+module Lookout
+  module Locations
+    class CountriesController < ApplicationController
+      include Limitable
+
+      before_action do
+        if Widget.disabled?(:locations, :countries)
+          raise Widget::WidgetDisabled.new("Widget disabled", :geography)
+        end
+      end
+
+      def index
+        results = cached(:countries) do
+          CountryQuery.call(params)
+                      .limit(limit)
+        end
+
+        @countries = paginate(results).map { |country| CountryDecorator.new(country, self) }
+      end
+    end
+  end
+end

data/app/controllers/lookout/locations/maps_controller.rb

@@ -0,0 +1,24 @@
+module Lookout
+  module Locations
+    class MapsController < ApplicationController
+      include Limitable
+
+      before_action do
+        if Widget.disabled?(:locations, :map)
+          raise Widget::WidgetDisabled.new("Widget disabled", :geography)
+        end
+      end
+
+      def show
+        if request.variant.include?(:details)
+          results = CountryQuery.call(params)
+          results = results.limit(limit)
+          @countries = paginate(results).map { |country| CountryDecorator.new(country, self) }
+          render template: 'lookout/locations/countries/index'
+        else
+          @countries = visit_query.where.not(country: nil).group("country").count
+        end
+      end
+    end
+  end
+end

data/app/controllers/lookout/locations/regions_controller.rb

@@ -0,0 +1,22 @@
+module Lookout
+  module Locations
+    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
+          RegionQuery.call(params)
+                     .limit(limit)
+        end
+
+        @regions = paginate(results).map { |region| RegionDecorator.new(region, self) }
+      end
+    end
+  end
+end

data/app/controllers/lookout/properties_controller.rb

@@ -0,0 +1,73 @@
+module Lookout
+  class PropertiesController < ApplicationController
+    before_action do
+      @options = extract_property_keys.map { |key| [Base64.urlsafe_encode64(key), key]}.to_h
+    end
+
+    def index
+      # Auto-select 'url' property if it exists, otherwise first property
+      if @options.any?
+        # Prefer 'url' property
+        url_key = @options.find { |key, value| value == 'url' }&.first
+        default_key = url_key || @options.keys.first
+        
+        redirect_to property_path(id: default_key, **request.query_parameters), status: :see_other
+      end
+    end
+
+    def show
+      value = Base64.urlsafe_decode64(params[:id])
+      json_extract = Lookout::DatabaseAdapter.json_extract_text("properties", value)
+      coalesce_expr = "COALESCE(#{json_extract}, '(none)')"
+
+      # Handle percentage calculation differently for SQLite vs PostgreSQL
+      percentage_calc = if Lookout::DatabaseAdapter.postgresql?
+        "(COUNT(DISTINCT visit_id)/COUNT(*)::numeric) * 100"
+      else
+        "(CAST(COUNT(DISTINCT visit_id) AS REAL) / COUNT(*)) * 100"
+      end
+
+      @properties = event_query
+        .select(
+          "#{coalesce_expr} AS label",
+          "COUNT(*) AS events_count",
+          "COUNT(DISTINCT visit_id) AS unique_visitors_count",
+          "#{percentage_calc} as percentage"
+        )
+        .group(coalesce_expr)
+        .order(Arel.sql "COUNT(*) desc")
+    end
+
+    private
+
+    helper_method :has_property?
+    def has_property?(value)
+      searching_properties[value]
+    end
+
+    helper_method :selected_property?
+    def selected_property?(value)
+      encoded = Base64.urlsafe_encode64(value, padding: false)
+      encoded == params[:id]
+    end
+
+    def searching_properties
+      JSON.parse(params.dig("q", "properties_json_cont") || '{}')
+    end
+
+    def extract_property_keys
+      if Lookout::DatabaseAdapter.postgresql?
+        ::Ahoy::Event
+          .select("jsonb_object_keys(properties) as keys")
+          .distinct
+          .pluck("jsonb_object_keys(properties)")
+      else
+        # SQLite: use json_each to extract keys
+        ::Ahoy::Event
+          .from("#{::Ahoy::Event.table_name}, json_each(#{::Ahoy::Event.table_name}.properties)")
+          .select("DISTINCT json_each.key as keys")
+          .pluck("json_each.key")
+      end
+    end
+  end
+end

data/app/controllers/lookout/realtimes_controller.rb

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

data/app/controllers/lookout/roots_controller.rb

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

data/app/controllers/lookout/sources_controller.rb

@@ -0,0 +1,21 @@
+module Lookout
+  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
+        SourceQuery.call(params)
+                   .limit(limit)
+      end
+
+      @sources = paginate(results).map { |source| Lookout::SourceDecorator.new(source, self) }
+    end
+  end
+
+end