lookout-ahoy 0.1.0

data/app/queries/concerns/lookout/comparable_query.rb

@@ -0,0 +1,152 @@
+module Lookout
+  module ComparableQuery
+    class Comparison
+      class ComparisonResult
+        attr_reader :current, :compared_to
+        def initialize(current, compared_to)
+          @current = current
+          @compared_to = compared_to
+        end
+      end
+
+      def initialize(query)
+        @query = query
+        @params = @query.params.deep_dup
+        @compare = @query.class.call(comparison_params)
+        @model = @query.all.klass
+        @query_class = @query.class
+      end
+
+      def count(column_name = :id)
+        @operation = :count
+        @column = column_name
+        perform_calculations(:count, column_name)
+
+        self
+      end
+
+      def average(column_name)
+        @operation = :average
+        @column = column_name
+
+        perform_calculations(:average, column_name)
+
+        self
+      end
+
+      def perform_calculations(operation, column_name)
+        @query = perform_calculation(@query, operation, column_name)
+        @compare = perform_calculation(@compare, operation, column_name)
+      end
+
+      def perform_calculation(q, operation, column_name)
+        operation = operation.to_s.downcase
+        # If #count is used with #distinct (i.e. `relation.distinct.count`) it is
+        # considered distinct.
+        distinct = q.send(:distinct_value)
+
+        if operation == "count"
+          column_name ||= q.send(:select_for_count)
+          if column_name == :all
+            if !distinct
+              distinct = q.send(:distinct_select?, :select_for_count) if q.group_values.empty?
+            elsif q.send(:group_values).any? || q.send(:select_values).empty? && q.order_values.empty?
+              column_name = q.primary_key
+            end
+          elsif q.all.send(:distinct_select?, column_name)
+            distinct = nil
+          end
+        end
+
+        if q.group_values.any?
+          raise "use a subquery"
+        else
+          execute_simple_calculation(q, operation, column_name, distinct)
+        end
+      end
+
+      def result
+        type = @query_class.cast_type(@column)
+
+        if Lookout::DatabaseAdapter.sqlite?
+          # SQLite: Use scalar subselects to avoid selecting bare CTE names
+          sql = "SELECT (#{@query.to_sql}) AS current, (#{@compare.to_sql}) AS compare"
+          row = @model.find_by_sql(sql).first
+          if row
+            current = @query_class.cast_value(type, row["current"].to_s)
+            compare = @query_class.cast_value(type, row["compare"].to_s)
+          else
+            current = @query_class.cast_value(type, '0')
+            compare = @query_class.cast_value(type, '0')
+          end
+        else
+          result = @model.with(
+            current: @query.to_sql,
+            compare: @compare.to_sql
+          ).select("current, compare").from("current, compare")[0]
+
+          if result
+            current = @query_class.cast_value(type, result.current[1...-1])
+            compare = @query_class.cast_value(type, result.compare[1...-1])
+          else
+            current = @query_class.cast_value(type, '0')
+            compare = @query_class.cast_value(type, '0')
+          end
+        end
+
+        @result = ComparisonResult.new((current), (compare))
+      end
+
+      def compare_range
+        @compare_range ||= begin
+                             og_range = range
+                             [og_range[0] - (og_range[1] - og_range[0]), og_range[0]]
+                           end
+
+      end
+
+      def range
+        @range ||= @query.send(:range)
+      end
+
+      private
+
+      def execute_simple_calculation(q, operation, column_name, distinct) # :nodoc:
+        if operation == "count" && (column_name == :all && distinct || q.has_limit_or_offset?)
+          # Shortcut when limit is zero.
+          return 0 if q.limit_value == 0
+
+          q.send(:build_count_subquery, q.spawn, column_name, distinct)
+        else
+          # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
+          relation = q.all.unscope(:order).distinct!(false)
+
+          column = q.all.send(:aggregate_column, column_name)
+          select_value = q.all.send(:operation_over_aggregate_column, column, operation, distinct)
+          select_value.distinct = true if operation == "sum" && distinct
+
+          relation.select_values = [select_value]
+
+          relation.arel
+        end
+      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
+
+    def with_comparison(enabled = false)
+      if enabled
+        Comparison.new(self)
+      else
+        self
+      end
+    end
+  end
+end

data/app/queries/concerns/lookout/lazy_comparable_query.rb

@@ -0,0 +1,42 @@
+module Lookout
+  module LazyComparableQuery
+    class LazyComparison
+      class LazyComparisonResult
+        attr_accessor :current, :compared_to
+      end
+
+      include ::Lookout::ComparableQueries
+
+      def initialize(query)
+        @query = query
+        @params = @query.params.deep_dup
+        @compare = @query.class.call(comparison_params)
+      end
+
+      def method_missing(name, *args)
+        perform_operations(name, *args)
+      end
+
+      def perform_operations(name, *args)
+        @query = @query.public_send(name, *args)
+        @compare = @compare.public_send(name, *args)
+
+        self
+      end
+
+      def result
+        return @result if @result
+
+        @result = LazyComparisonResult.new.tap { |comparison| comparison.current =  @query; comparison.compared_to = @compare }
+      end
+    end
+
+    def with_lazy_comparison(enabled = false)
+      if enabled
+        LazyComparison.new(self)
+      else
+        self
+      end
+    end
+  end
+end

data/app/queries/lookout/application_query.rb

@@ -0,0 +1,186 @@
+require_relative '../concerns/lookout/comparable_queries'
+
+module Lookout
+  class ApplicationQuery
+    # if you want to enforce returning a relation
+    class_attribute :strict, default: true
+
+    delegate_missing_to :@query
+
+    def self.inherited(klass)
+      klass.protected_methods :build
+      klass.private_methods :call
+    end
+
+    def self.call(params, query = nil)
+      new(params, query).send(:call)
+    end
+
+    attr_reader :params
+    def initialize(params, query)
+      @params = params
+      @query = query
+    end
+
+    def inspect
+      "<#{self.class.name}>"
+    end
+    protected
+
+    def build
+      raise NotImplementedError
+    end
+
+    private
+
+    def call
+      @query = build
+
+      if self.class.strict?
+        if @query.is_a?(ActiveRecord::Relation) || @query.class != self.class
+        else
+          raise ArgumentError, "#{self.class.name} has strict enabled, and should return a relation. Returned a #{@query.class}."
+        end
+      end
+
+      self
+    end
+
+    def visit_query
+      VisitQuery.call(params)
+    end
+
+    def event_query
+      EventQuery.call(params)
+    end
+
+    # this could be better
+    def ransack_params_for(type)
+      ransackable_params = {}
+
+      if params[:q]
+        ransackable_attributes = {
+          visit: (Lookout.visit.ransackable_attributes + Lookout.visit.ransackable_scopes).map(&:to_s),
+          event: (Lookout.event.ransackable_attributes + Lookout.event.ransackable_scopes).map(&:to_s),
+        }
+
+        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))
+            ransackable_params["visit_#{key}"] = value
+          elsif type == :visit && (ransackable_attributes[:event].include?(attribute_name) || ransackable_attributes[:event].include?(key))
+            ransackable_params["events_#{key}"] = value
+          else
+            ransackable_params[key] = value
+          end
+        end
+      end
+
+      merge_params = {}
+      ransackable_params.each do |k,v|
+        transform = false
+        if v == Lookout.none.value
+          transform = true
+        elsif v.is_a?(Array) && v[0] == Lookout.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.realtime?
+            ransackable_params['time_gt'] = range[0]
+            ransackable_params["visit_started_at_gt"] = range[0]
+          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.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]
+          end
+        end
+      end
+
+      ransackify(ransackable_params, type)
+    end
+
+    # merge both sets of ransackable params and ensure that they're being set on the correct association
+    # if we have params that reach across associations
+    def ransack_params
+      if self.class.name == "Lookout::EventQuery"
+        ransack_params_for(:event)
+      elsif self.class.name == "Lookout::VisitQuery"
+        ransack_params_for(:visit)
+      else
+        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/lookout/campaign_query.rb

@@ -0,0 +1,14 @@
+module Lookout
+  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/lookout/city_query.rb

@@ -0,0 +1,14 @@
+module Lookout
+  class CityQuery < ApplicationQuery
+    def build
+      # Use database-agnostic concat
+      concat_expr = Lookout::DatabaseAdapter.concat('city', 'region', 'country')
+      
+      visit_query
+        .select("city, country, count(#{concat_expr}) as count, sum(count(#{concat_expr})) over() as total_count")
+        .where.not(city: nil)
+        .group("city, region, country")
+        .order(Arel.sql "count(#{concat_expr}) desc")
+    end
+  end
+end

data/app/queries/lookout/country_query.rb

@@ -0,0 +1,10 @@
+module Lookout
+  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/lookout/device_query.rb

@@ -0,0 +1,10 @@
+module Lookout
+  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/lookout/entry_pages_query.rb

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

data/app/queries/lookout/event_query.rb

@@ -0,0 +1,42 @@
+module Lookout
+  class EventQuery < ApplicationQuery
+
+    def build
+      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") }
+
+      event = Lookout.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 = Lookout.visit.ransack(
+        visit_params, context: shared_context
+      )
+      shared_conditions = [search_parents, search_children].map { |search|
+        Ransack::Visitor.new.accept(search.base)
+      }
+
+      joined = Lookout.event.joins(shared_context.join_sources)
+
+      if entry_pages.values.any?(&:present?) || params[:controller].include?("entry_pages")
+        joined = joined.with_entry_pages
+      end
+
+      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 page_view
+      @query = @query.page_view
+
+      self
+    end
+  end
+end

data/app/queries/lookout/exit_pages_query.rb

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

data/app/queries/lookout/region_query.rb

@@ -0,0 +1,14 @@
+module Lookout
+  class RegionQuery < ApplicationQuery
+    def build
+      # Use database-agnostic concat
+      concat_expr = Lookout::DatabaseAdapter.concat('region', 'country')
+      
+      visit_query
+        .reselect("region, country, count(#{concat_expr}) as count, sum(count(region)) over() as total_count")
+        .where.not(region: nil)
+        .group("region, country")
+        .order(Arel.sql "count(#{concat_expr}) desc")
+    end
+  end
+end

data/app/queries/lookout/source_query.rb

@@ -0,0 +1,11 @@
+module Lookout
+  class SourceQuery < ApplicationQuery
+    def build
+      expr = Lookout::DatabaseAdapter.domain_from("referring_domain")
+      visit_query.select("#{expr} as referring_domain, count(#{expr}) as count, sum(count(#{expr})) OVER() as total_count")
+                 .where.not(referring_domain: nil)
+                 .group(expr)
+                 .order(Arel.sql "count(#{expr}) desc")
+    end
+  end
+end

data/app/queries/lookout/stats/average_views_per_visit_query.rb

@@ -0,0 +1,20 @@
+module Lookout
+  module Stats
+    # pls fix
+    class AverageViewsPerVisitQuery < BaseQuery
+      def build
+        subquery = event_query.select("count(ahoy_events.visit_id) as count").where(name: "$view").group(:visit_id)
+
+        Lookout.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
+end

data/app/queries/lookout/stats/average_visit_duration_query.rb

@@ -0,0 +1,34 @@
+module Lookout
+  module Stats
+    class AverageVisitDurationQuery < BaseQuery
+      def build
+        max_events = event_query.select("#{Lookout.event.table_name}.visit_id, max(#{Lookout.event.table_name}.time) as created_at").group("visit_id")
+        
+        # PostgreSQL has interval type, SQLite stores timestamp diff as numeric (seconds)
+        duration_cast = Lookout::DatabaseAdapter.postgresql? ? 
+          "avg((max_events.created_at - #{Lookout.visit.table_name}.started_at))::interval" :
+          "avg(julianday(max_events.created_at) - julianday(#{Lookout.visit.table_name}.started_at)) * 86400"
+        
+        visit_query.select("#{duration_cast} as average_visit_duration")
+                   .joins("LEFT JOIN (#{max_events.to_sql}) as max_events ON #{Lookout.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?
+          # SQLite returns numeric seconds, PostgreSQL returns interval string
+          if value.is_a?(Numeric) || value.to_s.match?(/^\d+(\.\d+)?$/)
+            value.to_f.seconds
+          else
+            ActiveSupport::Duration.parse(value)
+          end
+        else
+          0.seconds
+        end
+      end
+    end
+  end
+end

data/app/queries/lookout/stats/base_query.rb

@@ -0,0 +1,18 @@
+module Lookout
+  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/lookout/stats/bounce_rates_query.rb

@@ -0,0 +1,33 @@
+module Lookout
+  module Stats
+    class BounceRatesQuery < BaseQuery
+      def build
+        total_visits = visit_query.select("date(#{Lookout.visit.table_name}.started_at) as date, count(*) as count").group("date(#{Lookout.visit.table_name}.started_at)")
+        subquery = visit_query.select(:id, :started_at).joins(:events).group("#{Lookout.visit.table_name}.id, #{Lookout.visit.table_name}.started_at").having("count(#{Lookout.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)")
+
+        percent_expr = Lookout::DatabaseAdapter.percentage_calculation("single_page_visits.count", "total_visits.count")
+        daily_bounce_rate = ::Ahoy::Visit.select("total_visits.date, #{percent_expr} 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
+
+      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/lookout/stats/total_pageviews_query.rb

@@ -0,0 +1,9 @@
+module Lookout
+  module Stats
+    class TotalPageviewsQuery < BaseQuery
+      def build
+        event_query.page_view
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Lookout
+  module Stats
+    class TotalVisitorsQuery < BaseQuery
+      def build
+        visit_query.distinct.select(:id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Lookout
+  module Stats
+    class UniqueVisitorsQuery < BaseQuery
+      def build
+        visit_query.distinct.select(:visitor_token)
+      end
+    end
+  end
+end