ruby_cms 0.2.1.0 → 1.0.0

data/lib/generators/ruby_cms/templates/services/analytics_service.rb

@@ -0,0 +1,305 @@
+class AnalyticsService
+  CACHE_VERSION = "v3"
+  CACHE_DURATION = 10.minutes
+  MAX_POPULAR_PAGES = 10
+  MAX_REFERRERS = 10
+  MAX_LANDING_PAGES = 10
+  MAX_UTM_SOURCES = 10
+  HIGH_VOLUME_THRESHOLD = 1000
+  RAPID_REQUEST_THRESHOLD = 50
+
+  def initialize(start_date, end_date, period = nil)
+    @start_date = start_date.beginning_of_day
+    @end_date = end_date.end_of_day
+    @range = @start_date..@end_date
+    @period = period || determine_period_from_date_range
+  end
+
+  def dashboard_stats
+    Rails.cache.fetch(cache_key("dashboard_stats"), expires_in: CACHE_DURATION) do
+      {
+        total_page_views: page_view_events.count,
+        unique_visitors: visits.distinct.count(:visitor_token),
+        total_sessions: visits.distinct.count(:visit_token),
+        popular_pages: popular_pages_data,
+        top_visitors: visits.group(:ip).order(Arel.sql("COUNT(*) DESC")).limit(10).count,
+        hourly_activity: hourly_activity_data,
+        daily_activity: daily_activity_data,
+        daily_visitors: daily_visitors_data,
+        top_referrers: referrer_data,
+        browser_stats: browser_analysis,
+        device_stats: device_analysis,
+        recent_page_views: page_view_events.order(time: :desc).limit(20),
+        suspicious_activity: suspicious_activity_data,
+        os_stats: os_analysis,
+        landing_pages: landing_page_analysis,
+        utm_sources: utm_source_analysis
+      }
+    end
+  end
+
+  def page_stats(page_name)
+    events = page_view_events.where(page_name:)
+
+    {
+      page_views: events.order(time: :desc).limit(100),
+      stats: {
+        total_views: events.count,
+        unique_visitors: events.joins(:visit).distinct.count("ahoy_visits.visitor_token"),
+        avg_views_per_day: (events.count.to_f / days_in_range).round(2)
+      }
+    }
+  end
+
+  def visitor_stats(ip_address)
+    visitor_visits = visits.where(ip: ip_address)
+    events = page_view_events.joins(:visit).where(ahoy_visits: { ip: ip_address })
+
+    {
+      visitor_views: events.order(time: :desc).limit(100),
+      stats: {
+        total_views: events.count,
+        unique_pages: count_unique_pages(events),
+        first_visit: visitor_visits.minimum(:started_at),
+        last_visit: visitor_visits.maximum(:started_at)
+      }
+    }
+  end
+
+  private
+
+  def visits
+    @visits ||= Ahoy::Visit.where(started_at: @range).exclude_bots
+  end
+
+  def page_view_events
+    @page_view_events ||= Ahoy::Event.where(name: "page_view", time: @range)
+                                     .joins(:visit)
+                                     .merge(Ahoy::Visit.exclude_bots)
+  end
+
+  def cache_key(suffix)
+    "analytics:#{CACHE_VERSION}:#{@start_date.to_date}:#{@end_date.to_date}:#{@period}:#{suffix}"
+  end
+
+  def days_in_range
+    (@end_date.to_date - @start_date.to_date + 1).to_i
+  end
+
+  def count_unique_pages(events)
+    events.where.not(page_name: nil).distinct.count(:page_name)
+  end
+
+  def popular_pages_data
+    page_view_events.where.not(page_name: nil)
+                    .group(:page_name)
+                    .order(Arel.sql("count_all DESC"))
+                    .limit(MAX_POPULAR_PAGES)
+                    .count
+  end
+
+  def hourly_activity_data
+    events_table = Ahoy::Event.arel_table
+    hour_expr = Arel::Nodes::NamedFunction.new("TO_CHAR", [ events_table[:time], Arel::Nodes::SqlLiteral.new("'HH24'") ])
+
+    page_view_events.group(hour_expr)
+                    .order(hour_expr)
+                    .count
+  end
+
+  def daily_activity_data
+    case @period
+    when "day"
+      hourly_activity_data
+    when "week", "month"
+      group_by_date
+    when "year"
+      group_by_month
+    else
+      group_by_date
+    end
+  end
+
+  def daily_visitors_data
+    case @period
+    when "day"
+      {}
+    when "week", "month"
+      group_visitors_by_date
+    when "year"
+      group_visitors_by_month
+    else
+      group_visitors_by_date
+    end
+  end
+
+  def group_by_date
+    date_expr = Arel.sql("DATE(ahoy_events.time)")
+
+    # Use pluck to get date and count, then convert to hash
+    # This ensures proper date formatting for PostgreSQL
+    result = page_view_events.group(date_expr)
+                             .order(date_expr)
+                             .pluck(date_expr, Arel.sql("COUNT(*)"))
+
+    raw = {}
+    result.each do |date, count|
+      # Convert date to string format for consistency
+      date_key = date.kind_of?(Date) ? date.strftime("%Y-%m-%d") : date.to_s
+      raw[date_key] = count.to_i
+    end
+
+    fill_date_gaps(raw)
+  end
+
+  def group_visitors_by_date
+    date_expr = Arel.sql("DATE(ahoy_visits.started_at)")
+
+    result = {}
+    visits.select(date_expr.as("visit_date"))
+          .select(Arel.sql("COUNT(DISTINCT visitor_token) as visitor_count"))
+          .where(started_at: @range)
+          .group(date_expr)
+          .pluck(date_expr, Arel.sql("COUNT(DISTINCT visitor_token)"))
+          .each do |date, count|
+      result[date.to_s] = count.to_i
+    end
+
+    fill_date_gaps(result)
+  end
+
+  def group_by_month
+    events_table = Ahoy::Event.arel_table
+    month_expr = Arel::Nodes::NamedFunction.new("TO_CHAR", [ events_table[:time], Arel::Nodes::SqlLiteral.new("'YYYY-MM'") ])
+
+    raw = page_view_events.group(month_expr)
+                          .order(month_expr)
+                          .count
+    fill_month_gaps(raw)
+  end
+
+  def fill_date_gaps(raw)
+    (@start_date.to_date..@end_date.to_date).each_with_object({}) do |date, result|
+      key = date.strftime("%Y-%m-%d")
+      result[key] = raw[key] || 0
+    end
+  end
+
+  def fill_month_gaps(raw)
+    result = {}
+    current = @start_date.to_date.beginning_of_month
+    end_month = @end_date.to_date.beginning_of_month
+
+    while current <= end_month
+      key = current.strftime("%Y-%m")
+      result[key] = raw[key] || 0
+      current = current.next_month
+    end
+
+    result
+  end
+
+  def group_visitors_by_month
+    visits_table = Ahoy::Visit.arel_table
+    month_expr = Arel::Nodes::NamedFunction.new("TO_CHAR", [ visits_table[:started_at], Arel::Nodes::SqlLiteral.new("'YYYY-MM'") ])
+
+    result = visits.select(month_expr.as("visit_month"))
+                   .select(Arel.sql("COUNT(DISTINCT visitor_token) as visitor_count"))
+                   .where(started_at: @range)
+                   .group(month_expr)
+                   .pluck(month_expr, Arel.sql("COUNT(DISTINCT visitor_token)"))
+
+    raw = {}
+    result.each do |month, count|
+      raw[month.to_s] = count.to_i
+    end
+
+    fill_month_gaps(raw)
+  end
+
+  def referrer_data
+    visits.where.not(referrer: [ nil, "" ])
+          .group(:referrer)
+          .order(Arel.sql("COUNT(*) DESC"))
+          .limit(MAX_REFERRERS)
+          .count
+  end
+
+  def landing_page_analysis
+    visits.where.not(landing_page: nil)
+          .group(:landing_page)
+          .order(Arel.sql("COUNT(*) DESC"))
+          .limit(MAX_LANDING_PAGES)
+          .count
+  end
+
+  def utm_source_analysis
+    visits.where.not(utm_source: nil)
+          .group(:utm_source, :utm_medium)
+          .order(Arel.sql("COUNT(*) DESC"))
+          .limit(MAX_UTM_SOURCES)
+          .count
+          .transform_keys { |(source, medium)| "#{source}#{" / #{medium}" if medium}" }
+  end
+
+  def browser_analysis
+    visits.where.not(browser: nil).group(:browser).count
+  end
+
+  def device_analysis
+    visits.where.not(device_type: nil).group(:device_type).count
+  end
+
+  def os_analysis
+    visits.where.not(os: nil).group(:os).count
+  end
+
+  def suspicious_activity_data
+    [].tap do |suspicious|
+      detect_high_volume_ips(suspicious)
+      detect_rapid_requests(suspicious)
+    end
+  end
+
+  def detect_high_volume_ips(suspicious)
+    visits.group(:ip)
+          .having(Arel::Nodes::NamedFunction.new("COUNT", [ Arel.star ]).gt(HIGH_VOLUME_THRESHOLD))
+          .count
+          .each do |ip, count|
+      suspicious << {
+        type: "high_volume",
+        ip: ip,
+        count: count,
+        description: "High volume from IP #{ip}"
+      }
+    end
+  end
+
+  def detect_rapid_requests(suspicious)
+    visits_table = Ahoy::Visit.arel_table
+    minute_expr = Arel::Nodes::NamedFunction.new("TO_CHAR", [ visits_table[:started_at], Arel::Nodes::SqlLiteral.new("'YYYY-MM-DD HH24:MI'") ])
+
+    visits.group(:ip, minute_expr)
+          .having(Arel::Nodes::NamedFunction.new("COUNT", [ Arel.star ]).gt(RAPID_REQUEST_THRESHOLD))
+          .count
+          .each do |(ip, minute), count|
+      suspicious << {
+        type: "rapid_requests",
+        ip: ip,
+        count: count,
+        description: "Rapid requests from IP #{ip} at #{minute}"
+      }
+    end
+  end
+
+  def determine_period_from_date_range
+    days = (@end_date.to_date - @start_date.to_date).to_i
+
+    case days
+    when 0 then "day"
+    when 1..7 then "week"
+    when 8..30 then "month"
+    else "year"
+    end
+  end
+end

data/lib/generators/ruby_cms/templates/services/audit_log.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# AuditLog.record(actor:, action:, target:, summary:, request:, meta: {})
+#
+# Persists an AuditLogEntry. Never raises — audit failures must not break the
+# user-facing action. Errors are logged at warn level.
+module AuditLog
+  module_function
+
+  def record(action:, actor: nil, target: nil, summary: nil, request: nil, meta: {})
+    AuditLogEntry.create!(
+      actor_email: actor_email(actor),
+      actor_id: actor.respond_to?(:id) ? actor.id : nil,
+      action: action.to_s,
+      target_type: target_type(target),
+      target_id: target_id(target),
+      target_label: target_label(target),
+      summary: summary&.to_s&.truncate(500),
+      ip: request&.remote_ip,
+      user_agent: request&.user_agent&.truncate(500),
+      metadata: meta || {}
+    )
+  rescue StandardError => e
+    Rails.logger.warn("[AuditLog] failed to record action=#{action}: #{e.class}: #{e.message}")
+    nil
+  end
+
+  def actor_email(actor)
+    return "system"  if actor == :system
+    return "unknown" if actor.nil?
+
+    actor.respond_to?(:email_address) ? actor.email_address : actor.to_s
+  end
+
+  def target_type(target)
+    return nil if target.nil?
+    return target if target.kind_of?(String)
+
+    target.class.name
+  end
+
+  def target_id(target)
+    return nil unless target.respond_to?(:id)
+
+    target.id
+  end
+
+  def target_label(target)
+    return target if target.kind_of?(String)
+    return nil    if target.nil?
+
+    %i[title name email_address email slug key to_s].each do |m|
+      next unless target.respond_to?(m)
+
+      val = target.public_send(m)
+      return val.to_s.truncate(200) if val.present?
+    end
+    "#{target.class.name}##{target.id}"
+  end
+end

data/lib/generators/ruby_cms/templates/services/command_runner.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "open3"
+
+# Runs whitelisted Rake tasks and reads log tails for the admin Commands UI.
+class CommandRunner
+  class << self
+    # @param task [String] rake task, e.g. "ruby_cms:sync_content_blocks"
+    # @param params [Hash] free-form key=>value passed to the task as ENV vars (uppercased).
+    #   Boolean true → "1", false/nil/blank → not set.
+    # @return [Hash] { output:, exit_status:, duration_ms:, argv: }
+    def run_rake(task, params: {})
+      raise ArgumentError, "rake task blank" if task.to_s.strip.blank?
+
+      env = { "RAILS_ENV" => Rails.env.to_s }.merge(env_from_params(params))
+      argv = [ "bundle", "exec", "rake", task.to_s ]
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      stdout_and_stderr, status = Open3.capture2e(env, *argv, chdir: Rails.root.to_s)
+      duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).to_i
+      text = <<~TEXT.strip
+        $ #{cli_preview(argv, params)}
+        (exit #{status.exitstatus})
+
+        #{stdout_and_stderr}
+      TEXT
+      { output: text, exit_status: status.exitstatus.to_i, duration_ms: duration_ms, argv: argv }
+    rescue Errno::ENOENT => e
+      { output: "Failed to run command: #{e.message}", exit_status: -1, duration_ms: 0, argv: [] }
+    end
+
+    private
+
+    def env_from_params(params)
+      out = {}
+      Array(params).each do |k, v|
+        next if k.to_s.strip.empty?
+        key = k.to_s.upcase
+        case v
+        when true       then out[key] = "1"
+        when false, nil then next
+        else
+          str = v.to_s
+          out[key] = str unless str.empty?
+        end
+      end
+      out
+    end
+
+    def cli_preview(argv, params)
+      flags = Array(params).filter_map do |k, v|
+        next nil if k.to_s.empty?
+        case v
+        when true       then "--#{k}"
+        when false, nil then nil
+        else
+          str = v.to_s
+          str.empty? ? nil : "--#{k}=#{str}"
+        end
+      end
+      ([ argv.join(" ") ] + flags).reject(&:empty?).join(" ")
+    end
+
+    public
+
+    def tail_log(lines: 400, max_bytes: 512 * 1024)
+      path = Rails.root.join("log", "#{Rails.env}.log")
+      return "(Log file not found: #{path})" unless path.file?
+
+      File.open(path, "rb") do |f|
+        size = f.size
+        f.seek([ 0, size - max_bytes ].max)
+        chunk = f.read
+        chunk.lines.last(lines.to_i.clamp(1, 10_000)).join
+      end
+    rescue StandardError => e
+      "(Could not read log: #{e.message})"
+    end
+  end
+end

data/lib/generators/ruby_cms/templates/services/security_service.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+class SecurityService
+  CACHE_DURATION = 10.minutes
+  SECURITY_EVENT_TYPES = SecurityTracker::EVENT_TYPES
+
+  def initialize(start_date, end_date, period = nil)
+    @start_date = start_date.beginning_of_day
+    @end_date   = end_date.end_of_day
+    @range      = @start_date..@end_date
+    @period     = period || determine_period_from_date_range
+  end
+
+  def dashboard_stats
+    Rails.cache.fetch(cache_key("dashboard_stats"), expires_in: CACHE_DURATION) do
+      {
+        total_events: security_events.count,
+        high_risk_events: high_risk_events.count,
+        failed_logins: failed_login_events.count,
+        successful_logins: successful_login_events.count,
+        suspicious_activities: suspicious_activity_events.count,
+        top_threat_ips: top_threat_ips,
+        events_by_type: events_by_type,
+        recent_events: recent_events
+      }
+    end
+  end
+
+  def event_type_stats(event_type)
+    events = security_events.where(name: event_type)
+
+    {
+      events: events.order(time: :desc).limit(100),
+      stats: {
+        total: events.count,
+        unique_ips: events.distinct.count(:ip_address),
+        avg_per_day: average_per_day(events.count)
+      }
+    }
+  end
+
+  def ip_stats(ip_address)
+    events = security_events.where(ip_address:)
+
+    {
+      events: events.order(time: :desc).limit(100),
+      stats: {
+        total: events.count,
+        unique_event_types: events.distinct.count(:name),
+        first_seen: events.minimum(:time),
+        last_seen: events.maximum(:time)
+      }
+    }
+  end
+
+  private
+
+  def security_events
+    @security_events ||= Ahoy::Event.where(
+      name: SECURITY_EVENT_TYPES,
+      time: @range
+    )
+  end
+
+  def high_risk_events
+    security_events.where(name: %w[
+                            session_hijack_attempt
+                            unauthorized_admin_attempt
+                          ])
+  end
+
+  def failed_login_events
+    security_events.where(name: "failed_login")
+  end
+
+  def successful_login_events
+    security_events.where(name: "successful_login")
+  end
+
+  def suspicious_activity_events
+    security_events.where(name: %w[
+                            suspicious_user_agent
+                            unusual_request_pattern
+                          ])
+  end
+
+  def recent_events
+    filter_blocked_ips(
+      security_events.order(time: :desc).limit(20)
+    )
+  end
+
+  def events_by_type
+    security_events
+      .group(:name)
+      .order("count_id DESC")
+      .count(:id)
+  end
+
+  def top_threat_ips
+    security_events
+      .where.not(name: %w[successful_login logout])
+      .where.not(ip_address: nil)
+      .group(:ip_address)
+      .order(Arel.sql("count_all DESC"))
+      .limit(10)
+      .count
+  end
+
+  def events_over_time
+    case @period
+    when "day"
+      group_by_hour
+    when "week", "month"
+      group_by_date
+    when "year"
+      group_by_month
+    else
+      group_by_date
+    end
+  end
+
+  def group_by_hour
+    security_events
+      .group(Arel.sql("EXTRACT(HOUR FROM time)"))
+      .order(Arel.sql("EXTRACT(HOUR FROM time)"))
+      .count
+  end
+
+  def group_by_date
+    raw = security_events
+          .group(Arel.sql("DATE(time)"))
+          .order(Arel.sql("DATE(time)"))
+          .count
+
+    fill_date_gaps(raw)
+  end
+
+  def group_by_month
+    raw = security_events
+          .group(Arel.sql("TO_CHAR(time, 'YYYY-MM')"))
+          .order(Arel.sql("TO_CHAR(time, 'YYYY-MM')"))
+          .count
+
+    fill_month_gaps(raw)
+  end
+
+  def fill_date_gaps(raw)
+    (@start_date.to_date..@end_date.to_date).each_with_object({}) do |date, result|
+      key = date.to_s
+      result[key] = raw[key] || 0
+    end
+  end
+
+  def fill_month_gaps(raw)
+    result = {}
+    current = @start_date.to_date.beginning_of_month
+    last    = @end_date.to_date.beginning_of_month
+
+    while current <= last
+      key = current.strftime("%Y-%m")
+      result[key] = raw[key] || 0
+      current = current.next_month
+    end
+
+    result
+  end
+
+  def filter_blocked_ips(events)
+    return events if events.kind_of?(ActiveRecord::Relation) && !events.loaded?
+
+    blocked_ips = IpBlocklist.pluck(:ip_address).to_set
+
+    events.reject { it.ip_address.present? && blocked_ips.include?(it.ip_address) }
+  end
+
+  def average_per_day(count)
+    (count.to_f / days_in_range).round(2)
+  end
+
+  def days_in_range
+    (@end_date.to_date - @start_date.to_date + 1).to_i
+  end
+
+  def cache_key(suffix)
+    "security:v3:#{@start_date.to_date}:#{@end_date.to_date}:#{suffix}"
+  end
+
+  def determine_period_from_date_range
+    days = (@end_date.to_date - @start_date.to_date).to_i
+
+    case days
+    when 0
+      "day"
+    when 1..7
+      "week"
+    when 8..30
+      "month"
+    else
+      "year"
+    end
+  end
+end