ruby_cms 0.2.1.0 → 1.0.0

data/lib/generators/ruby_cms/templates/controllers/admin/analytics_controller.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+module Admin
+  class AnalyticsController < Admin::ApplicationController
+    before_action { require_permission!(:manage_analytics) }
+    before_action :set_date_range
+    before_action :validate_date_range
+
+    def index
+      report = Analytics::Report.new(
+        start_date: @start_date,
+        end_date: @end_date,
+        period: @period
+      )
+      @stats = report.dashboard_stats
+      @stats.each { |key, value| instance_variable_set(:"@#{key}", value) }
+      @active_users = active_users_count
+    end
+
+    def page_details
+      @page_name = sanitize_page_name(params[:page_name])
+      unless @page_name
+        return redirect_to admin_analytics_path,
+                           alert: t("ruby_cms.admin.analytics.invalid_page_name",
+                                    default: "Invalid page name.")
+      end
+
+      report = Analytics::Report.new(
+        start_date: @start_date,
+        end_date: @end_date,
+        period: @period
+      )
+      data = report.page_stats(@page_name)
+      @page_views = data[:page_views]
+      @page_stats = data[:stats]
+    end
+
+    def visitor_details
+      @ip_address = sanitize_ip_address(params[:ip_address])
+      unless @ip_address
+        return redirect_to admin_analytics_path,
+                           alert: t("ruby_cms.admin.analytics.invalid_ip_address",
+                                    default: "Invalid IP address.")
+      end
+
+      report = Analytics::Report.new(
+        start_date: @start_date,
+        end_date: @end_date,
+        period: @period
+      )
+      data = report.visitor_stats(@ip_address)
+      @visitor_views = data[:visitor_views]
+      @visitor_stats = data[:stats]
+    end
+
+    private
+
+    def set_date_range
+      @period = sanitize_period(params[:period]) || default_period
+
+      @start_date, @end_date = parsed_date_range || default_date_range
+    rescue Date::Error
+      @start_date, @end_date = fallback_date_range
+    end
+
+    def validate_date_range
+      max_days = RubyCms::Settings.get(:analytics_max_date_range_days, default: 365).to_i
+      return if valid_date_range?(max_days)
+
+      redirect_to admin_analytics_path,
+                  alert: "Invalid date range. Maximum range is #{max_days} days."
+    end
+
+    def active_users_count
+      Ahoy::Event
+        .where(name: Analytics::Report::EVENT_PAGE_VIEW)
+        .where(time: 5.minutes.ago..)
+        .joins(:visit)
+        .distinct
+        .count(:visitor_token)
+    rescue StandardError
+      nil
+    end
+
+    def sanitize_period(value)
+      %w[day week month year].include?(value.to_s) ? value.to_s : nil
+    end
+
+    def default_period
+      RubyCms::Settings.get(:analytics_default_period, default: "week").to_s
+    rescue StandardError
+      "week"
+    end
+
+    def period_start_date(period, end_date)
+      case period
+      when "day" then end_date
+      when "week" then end_date - 6.days
+      when "month" then end_date - 29.days
+      else end_date - 364.days
+      end
+    end
+
+    def sanitize_page_name(page_name)
+      page_name.to_s.gsub(%r{[^a-zA-Z0-9_\-/]}, "").presence
+    end
+
+    def sanitize_ip_address(ip_address)
+      return nil if ip_address.blank?
+
+      IPAddr.new(ip_address)
+      ip_address
+    rescue IPAddr::InvalidAddressError
+      nil
+    end
+
+    helper_method :format_chart_date, :format_chart_date_short, :format_chart_date_axis
+
+    def format_chart_date(date_string)
+      format_chart_date_by_granularity(date_string, long: true)
+    rescue Date::Error
+      date_string.to_s
+    end
+
+    def format_chart_date_short(date_string)
+      format_chart_date_by_granularity(date_string, long: false)
+    rescue Date::Error
+      date_string.to_s
+    end
+
+    # Compact x-axis tick for daily chart (month view: day number only to avoid crowded labels)
+    def format_chart_date_axis(date_string)
+      date = Date.parse(date_string.to_s)
+      return date.day.to_s if @period == "month"
+
+      format_chart_date_short(date_string)
+    rescue Date::Error
+      date_string.to_s
+    end
+
+    def format_daily_date(date_string)
+      date = Date.parse(date_string.to_s)
+      if @period == "month"
+        end_date = [ date + 2.days, @end_date ].min
+        return "#{date.strftime('%b %d')} - #{end_date.strftime('%b %d')}" if date != end_date
+      end
+      date.strftime("%B %d, %Y")
+    end
+
+    def format_daily_date_short(date_string)
+      date = Date.parse(date_string.to_s)
+      if @period == "month"
+        end_date = [ date + 2.days, @end_date ].min
+        return "#{date.strftime('%m/%d')}-#{end_date.strftime('%m/%d')}" if date != end_date
+      end
+      date.strftime("%m/%d")
+    end
+
+    def parsed_date_range
+      return nil unless params[:start_date].present? && params[:end_date].present?
+
+      [
+        Date.parse(params[:start_date]),
+        Date.parse(params[:end_date])
+      ]
+    end
+
+    def default_date_range
+      end_date = Date.current
+      [ period_start_date(@period, end_date), end_date ]
+    end
+
+    def fallback_date_range
+      end_date = Date.current
+      [ end_date - 6.days, end_date ]
+    end
+
+    def valid_date_range?(max_days)
+      return false unless @end_date.between?(@start_date, Date.current)
+
+      (@end_date - @start_date).to_i <= max_days
+    end
+
+    def format_chart_date_by_granularity(date_string, long:)
+      str = date_string.to_s
+
+      if str.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+        return long ? format_daily_date(str) : format_daily_date_short(str)
+      end
+
+      if str.match?(/\A\d{4}-\d{2}\z/)
+        format_monthly_date(str, long:)
+      elsif str.match?(/\A\d{2}\z/)
+        format_hourly_date(str, long:)
+      else
+        str
+      end
+    end
+
+    def format_monthly_date(date_string, long:)
+      date = Date.parse("#{date_string}-01")
+      long ? date.strftime("%B %Y") : date.strftime("%b")
+    end
+
+    def format_hourly_date(date_string, long:)
+      long ? "#{date_string}:00" : "#{date_string}h"
+    end
+  end
+end

data/lib/generators/ruby_cms/templates/controllers/admin/application_controller.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Admin
+  # Base for all /admin controllers. Ensures authentication and permission enforcement.
+  # Inherits from the host's ApplicationController (or config.admin_base_controller).
+  # This layout must not be used for public pages.
+  class ApplicationController < ::ApplicationController
+    helper Admin::AdminPageHelper
+    helper Admin::DashboardHelper
+    helper Admin::RelativeTimeHelper
+    helper Admin::UiHelper
+    helper SettingsHelper
+    layout "admin"
+    before_action :set_cms_locale
+    before_action :preload_nav_prefs
+    before_action :require_cms_access
+    before_action :validate_admin_session
+    after_action  :reset_nav_pref_cache
+
+    rescue_from ActiveRecord::RecordNotFound, with: :render_not_found
+
+    helper_method :current_user_cms, :require_permission!, :admin_notifications
+
+    # Lightweight notification feed shown in the topbar bell (Noticed).
+    def admin_notifications
+      @admin_notifications ||= begin
+        user = current_user_cms
+        if user.nil?
+          []
+        else
+          Rails.cache.fetch("admin.notifications.user_#{user.id}", expires_in: 30.seconds) do
+            user.notifications.unread.includes(:event).order(created_at: :desc).limit(10).map do |n|
+              {
+                id: "noticed:#{n.id}",
+                kind: n.respond_to?(:kind) ? n.kind.to_sym : :system,
+                title: n.respond_to?(:title) ? n.title.to_s : n.event&.params&.dig(:title).to_s,
+                body: n.respond_to?(:body) ? n.body.to_s : n.event&.params&.dig(:body).to_s,
+                ts: n.created_at,
+                url: n.respond_to?(:url) && n.url ? n.url : admin_audit_log_entries_path
+              }
+            end
+          end
+        end
+      end
+    rescue StandardError => e
+      Rails.logger.warn("[Admin] admin_notifications failed: #{e.class}: #{e.message}")
+      []
+    end
+
+    # Declare which registered page this controller serves.
+    # Looks up the permission from the nav_registry entry and sets a before_action.
+    # Usage: cms_page :media (requires a matching register_page call with key: :media)
+    def self.cms_page(key)
+      page_key = key.to_sym
+      before_action do
+        entry = RubyCms.nav_registry.find { |e| e[:key] == page_key }
+        if entry.nil?
+          if defined?(Rails.logger)
+            Rails.logger.warn("[RubyCMS] cms_page :#{page_key} has no matching register_page entry. " \
+                              "Only manage_admin is enforced.")
+          end
+        elsif entry[:permission].present?
+          require_permission!(entry[:permission].to_sym)
+        end
+      end
+    end
+
+    # Public API: dashboard block +data procs and host code may call this on the controller instance.
+    def current_user_cms
+      @current_user_cms ||= resolve_current_user
+    end
+
+    private
+
+    # Bulk-load all `nav_show_*` Preferences once so the sidebar render does
+    # not issue 50+ individual SELECTs.
+    def preload_nav_prefs
+      RubyCms::Settings.preload_preferences(prefix: "nav_show_")
+    end
+
+    def reset_nav_pref_cache
+      RubyCms::Settings.reset_preference_cache
+      RubyCms.reset_visible_nav_cache
+    end
+
+    def resolve_current_user
+      if respond_to?(:current_user, true)
+        send(:current_user)
+      else
+        Rails.application.config.ruby_cms.current_user_resolver&.call(self)
+      end
+    end
+
+    def require_cms_access
+      ensure_authenticated
+      return if current_user_cms&.can?(:manage_admin)
+
+      Rails.logger.warn "Unauthorized admin access attempt from IP: #{request.remote_ip}, User Agent: #{request.user_agent}"
+      log_security_event("admin_access_denied", "Unauthorized admin access attempt", user_id: current_user_cms&.id)
+      require_permission!(:manage_admin)
+    end
+
+    # Session hijack protection. If the session's recorded IP differs from the
+    # request IP, terminate the session and force re-auth.
+    def validate_admin_session
+      return unless authenticated?
+      return unless Current.session&.ip_address
+      return if Current.session.ip_address == request.remote_ip
+
+      Rails.logger.warn "Potential session hijacking detected. Session IP: #{Current.session.ip_address}, Request IP: #{request.remote_ip}"
+      log_security_event("session_hijack_attempt", "Session IP mismatch detected - potential hijacking attempt", user_id: Current.session.user&.id)
+      terminate_session
+      redirect_to new_session_path, alert: "Session security validation failed. Please log in again."
+    end
+
+    def ensure_authenticated
+      return if current_user_cms
+
+      if respond_to?(:require_authentication, true)
+        send(:require_authentication)
+      else
+        redirect_to cms_redirect_path, alert: t("ruby_cms.admin.base.authentication_required")
+      end
+    end
+
+    # Forbid (403) or redirect with flash. Default-deny: unknown permission = forbidden.
+    def require_permission!(permission_key, record: nil)
+      return if current_user_cms&.can?(permission_key, record:)
+
+      respond_to do |format|
+        format.html do
+          redirect_to(cms_redirect_path, alert: t("ruby_cms.admin.base.not_authorized"))
+        end
+        format.any { head :forbidden }
+      end
+    end
+
+    # Optional role gate. Example: before_action { require_role!(:admin) } in a subclass.
+    # Uses user.admin? when role is :admin (if the host's User responds to :admin?).
+    def require_role!(role)
+      return if current_user_cms.nil?
+      return if role == :admin && current_user_cms.respond_to?(:admin?) && current_user_cms.admin?
+
+      respond_to do |format|
+        format.html do
+          redirect_to cms_redirect_path, alert: t("ruby_cms.admin.base.not_authorized")
+        end
+        format.any { head :forbidden }
+      end
+    end
+
+    def cms_redirect_path
+      Rails.application.config.ruby_cms.unauthorized_redirect_path.presence || "/"
+    end
+
+    def render_not_found
+      render "errors/not_found",
+             status: :not_found,
+             layout: "admin"
+    end
+
+    def set_cms_locale
+      locale = session[:ruby_cms_locale].presence || session[:admin_locale].presence
+      return if locale.blank?
+
+      locale = locale.to_sym
+      return unless I18n.available_locales.include?(locale)
+
+      # Keep both session keys in sync for host app + engine controllers.
+      session[:ruby_cms_locale] = locale
+      session[:admin_locale] = locale
+      I18n.locale = locale
+    end
+
+    # Resolve parameter key for model params
+    # Checks if a specific key exists in params, otherwise falls back to model's param_key
+    # @param model_class [Class] The model class (e.g., ContentBlock)
+    # @param param_name [Symbol] The expected parameter name (e.g., :page)
+    # @return [Symbol] The resolved parameter key
+    def model_param_key(model_class, param_name)
+      params.key?(param_name) ? param_name : model_class.model_name.param_key.to_sym
+    end
+
+    public :current_user_cms
+  end
+end

data/lib/generators/ruby_cms/templates/controllers/admin/audit_log_entries_controller.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Admin
+  class AuditLogEntriesController < Admin::ApplicationController
+    include AdminPagination
+    include AdminTurboTable
+
+    paginates_with_pref :audit_log, default: 25
+
+    before_action { require_permission!(:manage_audit_log) }
+    before_action :set_entry, only: :show
+
+    SORTABLE = {
+      "time" => "created_at",
+      "actor" => "actor_email",
+      "action" => "action"
+    }.freeze
+
+    FILTERS = AuditLogEntry::BUCKETS + [ "all" ].freeze
+
+    def index
+      base = AuditLogEntry.all
+      base = base.by_actor(params[:actor]) if params[:actor].present?
+
+      @filter_counts = filter_counts(base)
+      @current_filter = FILTERS.include?(params[:filter]) ? params[:filter] : "all"
+
+      scope = base
+      scope = scope.by_bucket(@current_filter) unless @current_filter == "all"
+      scope = scope.search_fulltext(params[:search].to_s.strip) if params[:search].present?
+
+      @sort_column = SORTABLE.key?(params[:sort]) ? params[:sort] : "time"
+      @sort_direction = params[:direction] == "asc" ? "asc" : "desc"
+      scope = scope.reorder(Arel.sql("#{SORTABLE[@sort_column]} #{@sort_direction}"))
+
+      @actor_options = AuditLogEntry.where.not(actor_email: nil).distinct.pluck(:actor_email).sort
+      @current_actor = params[:actor]
+
+      @audit_log_entries = set_pagination_vars(scope)
+      turbo_render_index
+    end
+
+    def show; end
+
+    private
+
+    def set_entry
+      @audit_log_entry = AuditLogEntry.find(params[:id])
+    end
+
+    def filter_counts(scope)
+      # Single GROUP BY query — was N+1 calls to scope.by_bucket(b).count.
+      # CASE expression mirrors AuditLogEntry#bucket / by_bucket scope.
+      bucket_sql = Arel.sql(<<~SQL.squish)
+        CASE
+          WHEN action ~ '^(content_block|media|form|redirect)' THEN 'content'
+          WHEN action ~ '^(user|permission|token|login)'       THEN 'users'
+          WHEN action ~ '^(system|job|backup|deploy|cache|sitemap)' THEN 'system'
+          WHEN action ~ '(failed|webhook|integration|settings)' THEN 'security'
+          ELSE 'system'
+        END
+      SQL
+      grouped = scope.group(bucket_sql).count
+      counts = { all: grouped.values.sum }
+      AuditLogEntry::BUCKETS.each { |b| counts[b.to_sym] = grouped[b].to_i }
+      counts
+    end
+  end
+end

data/lib/generators/ruby_cms/templates/controllers/admin/commands_controller.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Admin
+  class CommandsController < Admin::ApplicationController
+    include AuditLoggable
+
+    cms_page :commands
+
+    HISTORY_LIMIT = 30
+
+    def index
+      @commands = visible_commands
+      @last_runs = CommandRun.last_per_key
+                             .where(command_key: @commands.map { |c| c[:key] })
+                             .index_by(&:command_key)
+      @history = CommandRun.recent.includes(:ran_by).limit(HISTORY_LIMIT).to_a
+      @category_counts = build_category_counts(@commands)
+    end
+
+    def run
+      key = params[:key].presence || params.dig(:command, :key)
+      cmd = RubyCms.find_command(key)
+      unless cmd
+        respond_to do |format|
+          format.html { redirect_to admin_settings_commands_path, alert: t("ruby_cms.admin.commands.unknown", default: "Unknown command.") }
+          format.json { render json: { error: "Unknown command" }, status: :not_found }
+        end
+        return
+      end
+
+      require_permission!(cmd[:permission])
+
+      cmd_params = sanitized_params_for(cmd)
+      started_at = Time.current
+      result = CommandRunner.run_rake(cmd[:rake_task], params: cmd_params)
+      output = utf8_text(result[:output])
+
+      run_record = CommandRun.create!(
+        command_key:   cmd[:key],
+        status:        result[:exit_status].to_i.zero? ? "ok" : "failed",
+        duration_ms:   result[:duration_ms].to_i,
+        output:        output,
+        params_used:   cmd_params,
+        ran_by:        respond_to?(:current_user, true) ? current_user : nil,
+        ran_by_label:  user_label(current_user_cms),
+        started_at:    started_at
+      )
+
+      audit!(
+        run_record.status == "ok" ? :command_completed : :command_failed,
+        target: "Command:#{cmd[:key]}",
+        summary: "Ran rake #{cmd[:rake_task]} (#{run_record.status}, #{run_record.duration_ms}ms)",
+        meta: { key: cmd[:key], rake_task: cmd[:rake_task], status: run_record.status, duration_ms: run_record.duration_ms, params: cmd_params }
+      )
+
+      respond_to do |format|
+        format.html { redirect_to admin_settings_commands_path(active: cmd[:key]) }
+        format.json do
+          render json: {
+            run: run_payload(run_record),
+            command_output: output,
+            app_log_tail: utf8_text(CommandRunner.tail_log)
+          }
+        end
+      end
+    rescue StandardError => e
+      Rails.logger.error("[RubyCMS] Commands#run: #{e.class}: #{e.message}")
+      audit!(:command_failed, target: "Command:#{key}", summary: "rake #{key} crashed: #{e.message.to_s.truncate(200)}", meta: { key: key, error: e.message })
+      begin
+        CommandRun.create!(
+          command_key:   key.to_s,
+          status:        "failed",
+          duration_ms:   0,
+          error_message: e.message,
+          ran_by:        respond_to?(:current_user, true) ? current_user : nil,
+          ran_by_label:  user_label(current_user_cms),
+          started_at:    Time.current
+        )
+      rescue StandardError
+        nil
+      end
+      respond_to do |format|
+        format.html { redirect_to admin_settings_commands_path, alert: e.message }
+        format.json { render json: { error: e.message }, status: :unprocessable_content }
+      end
+    end
+
+    private
+
+    def user_label(user)
+      return nil if user.nil?
+      return user.email_address if user.respond_to?(:email_address) && user.email_address.present?
+      return user.email if user.respond_to?(:email) && user.email.present?
+      nil
+    end
+
+    def utf8_text(value)
+      return +"" if value.nil?
+      value.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "?")
+    end
+
+    def visible_commands
+      RubyCms.registered_commands
+             .select { |c| current_user_cms&.can?(c[:permission]) }
+             .sort_by { |c| [ (c[:category] || "custom"), c[:label].to_s.downcase, c[:key] ] }
+    end
+
+    def build_category_counts(commands)
+      counts = Hash.new(0)
+      commands.each { |c| counts[c[:category] || "custom"] += 1 }
+      counts["all"] = commands.size
+      counts
+    end
+
+    def sanitized_params_for(cmd)
+      raw = params[:command_params].presence || params[:params].presence || {}
+      raw = raw.respond_to?(:to_unsafe_h) ? raw.to_unsafe_h : raw.to_h
+      out = {}
+      Array(cmd[:params]).each do |descriptor|
+        k = descriptor[:key]
+        next if k.blank?
+        v = raw[k] || raw[k.to_sym]
+        out[k] =
+          case descriptor[:type]
+          when "toggle" then ActiveModel::Type::Boolean.new.cast(v)
+          when "select" then descriptor[:options].include?(v.to_s) ? v.to_s : descriptor[:default].to_s
+          else               v.to_s
+          end
+      end
+      out
+    end
+
+    def run_payload(run)
+      {
+        id: run.id,
+        command_key: run.command_key,
+        status: run.status,
+        duration_ms: run.duration_ms,
+        ran_by: run.by_label,
+        started_at: run.started_at.iso8601,
+        params_used: run.params_used,
+        output: run.output.to_s
+      }
+    end
+  end
+end

data/lib/generators/ruby_cms/templates/controllers/admin/content_block_versions_controller.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Admin
+  class ContentBlockVersionsController < Admin::ApplicationController
+    include AuditLoggable
+
+    before_action { require_permission!(:manage_content_blocks) }
+    before_action :set_content_block
+    before_action :set_version, only: %i[show rollback]
+
+    def index
+      @versions = @content_block.versions.reverse_chronologically.preloaded
+
+      respond_to do |format|
+        format.html
+        format.json { render json: versions_json }
+      end
+    end
+
+    def show
+      @previous_version = @version.previous
+    end
+
+    def rollback
+      @content_block.rollback_to_version!(@version, user: current_user_cms)
+      audit!(
+        :content_block_rolled_back,
+        target: @content_block,
+        summary: "Rolled back #{@content_block.key} to version #{@version.version_number}",
+        meta: { content_block_id: @content_block.id, version_id: @version.id, version_number: @version.version_number }
+      )
+      redirect_to admin_content_block_versions_path(@content_block),
+                  notice: "Teruggedraaid naar versie #{@version.version_number}"
+    end
+
+    private
+
+    def set_content_block
+      @content_block = ContentBlock.find(params[:content_block_id])
+    end
+
+    def set_version
+      @version = @content_block.versions.find(params[:id])
+    end
+
+    def versions_json
+      # Walk chronologically so we can compute diff-from-previous per version.
+      list = @versions.to_a
+      prev_by_id = list.each_with_index.to_h do |v, i|
+        [ v.id, list[i + 1] ] # @versions ordered reverse-chrono => next item is older
+      end
+
+      list.map do |v|
+        previous = prev_by_id[v.id]
+        diff = v.diff_from(previous)
+        {
+          id: v.id,
+          version_number: v.version_number,
+          event: v.event,
+          user: display_user(v.user),
+          created_at: v.created_at.strftime("%Y-%m-%d %H:%M"),
+          created_at_iso: v.created_at.iso8601,
+          content_type: v.content_type,
+          title: v.title,
+          published: v.published,
+          content_preview: content_preview_for(v),
+          changed_fields: diff.keys.map(&:to_s),
+          diff: diff.transform_values { |h| { old: stringify(h[:old]), new: stringify(h[:new]) } },
+          metadata: v.metadata
+        }
+      end
+    end
+
+    def content_preview_for(version)
+      raw = version.rich_content_html.presence || version.content.to_s
+      ActionController::Base.helpers.strip_tags(raw).gsub(/\s+/, " ").strip.truncate(280)
+    end
+
+    def stringify(value)
+      case value
+      when nil          then ""
+      when true, false  then value.to_s
+      else                   ActionController::Base.helpers.strip_tags(value.to_s).gsub(/\s+/, " ").strip.truncate(400)
+      end
+    end
+
+    def display_user(user)
+      return "System" if user.blank?
+
+      %i[email_address email username name].each do |attr|
+        return user.public_send(attr) if user.respond_to?(attr) && user.public_send(attr).present?
+      end
+      user.respond_to?(:id) ? "User ##{user.id}" : "System"
+    end
+  end
+end