ruby_cms 0.2.1.1 → 1.0.0

data/app/services/ruby_cms/analytics/report.rb

@@ -1,512 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  module Analytics
-    class Report
-      DEFAULT_CACHE_DURATION_SECONDS = 600
-      DEFAULT_MAX_POPULAR_PAGES = 10
-      DEFAULT_MAX_TOP_VISITORS = 10
-      DEFAULT_MAX_REFERRERS = 10
-      DEFAULT_MAX_LANDING_PAGES = 10
-      DEFAULT_MAX_UTM_SOURCES = 10
-      DEFAULT_HIGH_VOLUME_THRESHOLD = 1000
-      DEFAULT_RAPID_REQUEST_THRESHOLD = 50
-      DEFAULT_RECENT_PAGE_VIEWS_LIMIT = 25
-      DEFAULT_PAGE_DETAILS_LIMIT = 100
-      DEFAULT_VISITOR_DETAILS_LIMIT = 100
-      DEFAULT_MAX_EXIT_PAGES = 10
-      DEFAULT_MAX_CONVERSIONS = 10
-
-      # Supported Ahoy event names. Use these constants when calling ahoy.track in the host app.
-      #   page_view:  tracked automatically via RubyCms::PageTracking (page_name:, request_path:)
-      #   conversion: tracked by the host app, e.g. ahoy.track "conversion", goal: "contact_form"
-      EVENT_PAGE_VIEW = "page_view"
-      EVENT_CONVERSION = "conversion"
-
-      def initialize(start_date:, end_date:, period: nil)
-        @start_date = start_date.to_date.beginning_of_day
-        @end_date = end_date.to_date.end_of_day
-        @period = period.presence || RubyCms::Settings.get(:analytics_default_period,
-                                                           default: "week").to_s
-        @range = @start_date..@end_date
-      end
-
-      def dashboard_stats
-        Rails.cache.fetch(cache_key("dashboard"), expires_in: cache_duration) do
-          dashboard_stats_payload
-        end
-      end
-
-      def page_stats(page_name)
-        scoped = page_view_events.where(page_name:)
-
-        {
-          page_views: scoped.order(time: :desc).limit(page_details_limit),
-          stats: {
-            total_views: scoped.count,
-            unique_visitors: scoped.joins(:visit).distinct.count("ahoy_visits.visitor_token"),
-            avg_views_per_day: (scoped.count.to_f / days_in_range).round(2)
-          }
-        }
-      end
-
-      def visitor_stats(ip_address)
-        visitor_visits = visits.where(ip: ip_address)
-        visitor_events = page_view_events.joins(:visit).where(ahoy_visits: { ip: ip_address })
-
-        {
-          visitor_views: visitor_events.order(time: :desc).limit(visitor_details_limit),
-          stats: {
-            total_views: visitor_events.count,
-            unique_pages: visitor_events.where.not(page_name: [nil, ""]).distinct.count(:page_name),
-            first_visit: visitor_visits.minimum(:started_at),
-            last_visit: visitor_visits.maximum(:started_at)
-          }
-        }
-      end
-
-      private
-
-      def ruby_cms_config
-        Rails.application.config.ruby_cms
-      end
-
-      def cache_duration
-        RubyCms::Settings.get(
-          :analytics_cache_duration_seconds,
-          default: DEFAULT_CACHE_DURATION_SECONDS
-        ).to_i.seconds
-      rescue StandardError
-        DEFAULT_CACHE_DURATION_SECONDS.seconds
-      end
-
-      def cache_key(suffix)
-        "ruby_cms:analytics:#{@start_date.to_date}:#{@end_date.to_date}:#{@period}:#{suffix}"
-      end
-
-      def visits
-        base = Ahoy::Visit.where(started_at: @range)
-        # Use all visits by default so existing DB records are included. Bot exclusion
-        # can be applied via config.analytics_visit_scope (e.g. ->(s) { s.exclude_bots }).
-        apply_visit_scope_hook(base)
-      end
-
-      def page_view_events
-        base = Ahoy::Event.where(name: EVENT_PAGE_VIEW, time: @range).joins(:visit).merge(visits)
-        apply_event_scope_hook(base)
-      end
-
-      def conversion_events
-        base = Ahoy::Event.where(name: EVENT_CONVERSION, time: @range).joins(:visit).merge(visits)
-        apply_event_scope_hook(base)
-      end
-
-      def apply_visit_scope_hook(scope)
-        hook = ruby_cms_config.analytics_visit_scope
-        return scope unless hook.respond_to?(:call)
-
-        hook.call(scope)
-      rescue StandardError
-        scope
-      end
-
-      def apply_event_scope_hook(scope)
-        hook = ruby_cms_config.analytics_event_scope
-        return scope unless hook.respond_to?(:call)
-
-        hook.call(scope)
-      rescue StandardError
-        scope
-      end
-
-      def popular_pages_data
-        limit = RubyCms::Settings.get(:analytics_max_popular_pages,
-                                      default: DEFAULT_MAX_POPULAR_PAGES).to_i
-
-        page_view_events
-          .where.not(page_name: [nil, ""])
-          .group(:page_name)
-          .order(Arel.sql("count_all DESC"))
-          .limit(limit)
-          .count
-      end
-
-      def top_visitors_data
-        limit = RubyCms::Settings.get(:analytics_max_top_visitors,
-                                      default: DEFAULT_MAX_TOP_VISITORS).to_i
-        visits.group(:ip).order(Arel.sql("COUNT(*) DESC")).limit(limit).count
-      end
-
-      def hourly_activity_data
-        # Portable: group in Ruby so we work on SQLite, PostgreSQL, MySQL
-        raw = page_view_events.pluck(:time).each_with_object(Hash.new(0)) do |t, acc|
-          acc[t.utc.strftime("%H")] += 1
-        end
-        ("00".."23").index_with {|h| raw[h] || 0 }.sort.to_h
-      end
-
-      def daily_activity_data
-        case @period
-        when "day"
-          hourly_activity_data
-        when "year"
-          group_by_month
-        else
-          group_by_date
-        end
-      end
-
-      def group_by_date
-        result = Hash.new(0)
-        page_view_events.pluck(:time).each do |time|
-          result[time.to_date.strftime("%Y-%m-%d")] += 1
-        end
-        fill_date_gaps(result)
-      end
-
-      def group_by_month
-        raw = page_view_events.pluck(:time).each_with_object(Hash.new(0)) do |t, acc|
-          acc[t.strftime("%Y-%m")] += 1
-        end
-        fill_month_gaps(raw)
-      end
-
-      def fill_month_gaps(data)
-        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] = data[key] || 0
-          current = current.next_month
-        end
-        result
-      end
-
-      def daily_visitors_data
-        case @period
-        when "day"
-          {}
-        when "year"
-          group_visitors_by_month
-        else
-          group_visitors_by_date
-        end
-      end
-
-      def group_visitors_by_date
-        h = visits.pluck(:visitor_token, :started_at).each_with_object(Hash.new do |hash, k|
-          hash[k] = Set.new
-        end) do |(vt, st), acc|
-          next if st.blank?
-
-          key = st.respond_to?(:strftime) ? st.strftime("%Y-%m-%d") : st.to_s[0, 10]
-          acc[key] << vt
-        end
-        fill_date_gaps(h.transform_values(&:size))
-      end
-
-      def group_visitors_by_month
-        h = visits.pluck(:visitor_token, :started_at).each_with_object(Hash.new do |hash, k|
-          hash[k] = Set.new
-        end) do |(vt, st), acc|
-          next if st.blank?
-
-          key = st.respond_to?(:strftime) ? st.strftime("%Y-%m") : st.to_s[0, 7]
-          acc[key] << vt
-        end
-        raw = h.transform_values(&:size)
-        fill_month_gaps(raw)
-      end
-
-      def referrer_data
-        limit = RubyCms::Settings.get(:analytics_max_referrers, default: DEFAULT_MAX_REFERRERS).to_i
-        return {} unless Ahoy::Visit.column_names.include?("referrer")
-
-        visits.where.not(referrer: [nil, ""])
-              .group(:referrer)
-              .order(Arel.sql("COUNT(*) DESC"))
-              .limit(limit)
-              .count
-      end
-
-      def landing_pages_data
-        limit = RubyCms::Settings.get(:analytics_max_landing_pages,
-                                      default: DEFAULT_MAX_LANDING_PAGES).to_i
-        return {} unless Ahoy::Visit.column_names.include?("landing_page")
-
-        visits.where.not(landing_page: [nil, ""])
-              .group(:landing_page)
-              .order(Arel.sql("COUNT(*) DESC"))
-              .limit(limit)
-              .count
-      end
-
-      def utm_sources_data
-        limit = RubyCms::Settings.get(:analytics_max_utm_sources,
-                                      default: DEFAULT_MAX_UTM_SOURCES).to_i
-        return {} unless Ahoy::Visit.column_names.include?("utm_source")
-
-        raw = visits.where.not(utm_source: [nil, ""])
-                    .group(:utm_source, :utm_medium)
-                    .order(Arel.sql("COUNT(*) DESC"))
-                    .limit(limit)
-                    .count
-        raw.transform_keys do |(source, medium)|
-          "#{source}#{" / #{medium}" if medium.present?}"
-        end
-      end
-
-      def suspicious_activity_data
-        [].tap do |items|
-          add_high_volume_ips(items)
-          add_rapid_requests(items)
-        end
-      end
-
-      def add_high_volume_ips(items)
-        threshold = RubyCms::Settings.get(
-          :analytics_high_volume_threshold,
-          default: DEFAULT_HIGH_VOLUME_THRESHOLD
-        ).to_i
-
-        visits.group(:ip).having("COUNT(*) > ?", threshold).count.each do |ip, count|
-          items << {
-            type: "high_volume",
-            ip: ip,
-            count: count,
-            description: "High volume traffic from IP #{ip}"
-          }
-        end
-      end
-
-      def add_rapid_requests(items)
-        threshold = RubyCms::Settings.get(
-          :analytics_rapid_request_threshold,
-          default: DEFAULT_RAPID_REQUEST_THRESHOLD
-        ).to_i
-
-        per_ip_per_minute = Hash.new(0)
-        visits.pluck(:ip, :started_at).each do |ip, started_at|
-          next if started_at.blank?
-
-          minute_key = if started_at.respond_to?(:strftime)
-                         started_at.strftime("%Y-%m-%d %H:%M")
-                       else
-                         started_at.to_s[0,
-                                         16]
-                       end
-          per_ip_per_minute[[ip, minute_key]] += 1
-        end
-
-        per_ip_per_minute.each do |(ip, minute_key), count|
-          next unless count > threshold
-
-          items << {
-            type: "rapid_requests",
-            ip: ip,
-            count: count,
-            description: "Rapid requests from #{ip} at #{minute_key}"
-          }
-        end
-      end
-
-      def parse_event_properties(props)
-        return props if props.kind_of?(Hash)
-
-        JSON.parse(props.to_s)
-      rescue StandardError
-        {}
-      end
-
-      def conversion_stats_data
-        limit = RubyCms::Settings.get(:analytics_max_conversions, default: DEFAULT_MAX_CONVERSIONS).to_i
-        total = conversion_events.count
-        grouped = conversion_events.pluck(:properties).each_with_object(Hash.new(0)) do |props, acc|
-          parsed = parse_event_properties(props)
-          goal = parsed["goal"].presence || "unknown"
-          acc[goal] += 1
-        end
-        by_goal = grouped.sort_by {|_, count| -count }.first(limit).to_h
-        { total:, by_goal: }
-      rescue StandardError
-        { total: 0, by_goal: {} }
-      end
-
-      def exit_pages_data
-        limit = RubyCms::Settings.get(:analytics_max_exit_pages, default: DEFAULT_MAX_EXIT_PAGES).to_i
-
-        # Single DB query: subquery finds the latest event time per visit, outer query
-        # counts how often each page_name appears as the last page of a session.
-        last_times_sql = page_view_events
-                         .select(:visit_id, Arel.sql("MAX(ahoy_events.time) AS max_time"))
-                         .group(:visit_id)
-                         .to_sql
-
-        Ahoy::Event
-          .joins("INNER JOIN (#{last_times_sql}) last_pv
-                    ON ahoy_events.visit_id = last_pv.visit_id
-                   AND ahoy_events.time     = last_pv.max_time")
-          .where(name: EVENT_PAGE_VIEW, time: @range)
-          .where.not(page_name: [nil, ""])
-          .group(:page_name)
-          .order(Arel.sql("COUNT(*) DESC"))
-          .limit(limit)
-          .count
-      rescue StandardError
-        {}
-      end
-
-      def previous_period_start
-        @previous_period_start ||= @start_date - days_in_range.days
-      end
-
-      def previous_period_end
-        @previous_period_end ||= @start_date - 1.second
-      end
-
-      def previous_visits
-        base = Ahoy::Visit.where(started_at: previous_period_start..previous_period_end)
-        apply_visit_scope_hook(base)
-      end
-
-      def previous_page_view_events
-        base = Ahoy::Event
-               .where(name: EVENT_PAGE_VIEW, time: previous_period_start..previous_period_end)
-               .joins(:visit)
-               .merge(previous_visits)
-        apply_event_scope_hook(base)
-      end
-
-      def previous_period_totals
-        {
-          total_page_views: previous_page_view_events.count,
-          unique_visitors: previous_visits.distinct.count(:visitor_token),
-          total_sessions: previous_visits.distinct.count(:visit_token)
-        }
-      rescue StandardError
-        {}
-      end
-
-      def compute_delta(current, previous)
-        return nil if previous.to_i.zero?
-
-        ((current.to_f - previous.to_f) / previous.to_f * 100).round(1)
-      end
-
-      def compute_period_deltas(current_views, current_visitors, current_sessions)
-        prev = previous_period_totals
-        return {} if prev.empty?
-
-        {
-          total_page_views: compute_delta(current_views, prev[:total_page_views]),
-          unique_visitors: compute_delta(current_visitors, prev[:unique_visitors]),
-          total_sessions: compute_delta(current_sessions, prev[:total_sessions])
-        }
-      rescue StandardError
-        {}
-      end
-
-      def fill_date_gaps(data)
-        (@start_date.to_date..@end_date.to_date).each_with_object({}) do |date, acc|
-          key = date.strftime("%Y-%m-%d")
-          acc[key] = data[key] || 0
-        end
-      end
-
-      def extra_cards_data
-        hook = ruby_cms_config.analytics_extra_cards
-        return [] unless hook.respond_to?(:call)
-
-        cards = hook.call(
-          start_date: @start_date.to_date,
-          end_date: @end_date.to_date,
-          period: @period,
-          visits_scope: visits,
-          events_scope: page_view_events
-        )
-        Array(cards)
-      rescue StandardError
-        []
-      end
-
-      def compute_bounce_rate
-        total = visits.distinct.count(:visit_token)
-        return 0 unless total.positive?
-
-        event_counts = page_view_events.group(:visit_id).count
-        single_page = event_counts.count {|_, c| c == 1 }
-        ((single_page.to_f / total) * 100).round(1)
-      rescue StandardError
-        0
-      end
-
-      def compute_new_visitor_percentage
-        total = visits.distinct.count(:visitor_token)
-        return 0 unless total.positive?
-
-        # Subquery keeps everything in the DB; avoids loading all historical tokens into Ruby.
-        returning_subquery = Ahoy::Visit
-                             .where(started_at: ...@start_date)
-                             .select(:visitor_token)
-
-        new_count = visits.where.not(visitor_token: returning_subquery).distinct.count(:visitor_token)
-        ((new_count.to_f / total) * 100).round(0).to_i
-      rescue StandardError
-        0
-      end
-
-      def days_in_range
-        (@end_date.to_date - @start_date.to_date + 1).to_i
-      end
-
-      def recent_page_views_limit
-        RubyCms::Settings.get(:analytics_recent_page_views_limit,
-                              default: DEFAULT_RECENT_PAGE_VIEWS_LIMIT).to_i
-      end
-
-      def page_details_limit
-        RubyCms::Settings.get(:analytics_page_details_limit,
-                              default: DEFAULT_PAGE_DETAILS_LIMIT).to_i
-      end
-
-      def visitor_details_limit
-        RubyCms::Settings.get(:analytics_visitor_details_limit,
-                              default: DEFAULT_VISITOR_DETAILS_LIMIT).to_i
-      end
-
-      def dashboard_stats_payload
-        total_views = page_view_events.count
-        total_sessions = visits.distinct.count(:visit_token)
-        unique_visitors = visits.distinct.count(:visitor_token)
-
-        {
-          total_page_views: total_views,
-          unique_visitors: unique_visitors,
-          total_sessions: total_sessions,
-          pages_per_session: total_sessions.positive? ? (total_views.to_f / total_sessions).round(1) : 0,
-          bounce_rate: compute_bounce_rate,
-          new_visitor_percentage: compute_new_visitor_percentage,
-          avg_daily_views: days_in_range.positive? ? (total_views.to_f / days_in_range).round(0).to_i : 0,
-          popular_pages: popular_pages_data,
-          top_visitors: top_visitors_data,
-          hourly_activity: hourly_activity_data,
-          daily_activity: daily_activity_data,
-          daily_visitors: daily_visitors_data,
-          top_referrers: referrer_data,
-          landing_pages: landing_pages_data,
-          utm_sources: utm_sources_data,
-          browser_stats: visits.where.not(browser: [nil, ""]).group(:browser).count,
-          device_stats: visits.where.not(device_type: [nil, ""]).group(:device_type).count,
-          os_stats: visits.where.not(os: [nil, ""]).group(:os).count,
-          suspicious_activity: suspicious_activity_data,
-          recent_page_views: page_view_events.order(time: :desc).limit(recent_page_views_limit),
-          extra_cards: extra_cards_data,
-          conversions: conversion_stats_data,
-          exit_pages: exit_pages_data,
-          period_deltas: compute_period_deltas(total_views, unique_visitors, total_sessions)
-        }
-      end
-    end
-  end
-end

data/app/services/ruby_cms/command_runner.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-
-module RubyCms
-  # Runs whitelisted Rake tasks and reads log tails for the admin Commands UI.
-  class CommandRunner
-    class << self
-      def run_rake(task)
-        raise ArgumentError, "rake task blank" if task.to_s.strip.blank?
-
-        env = { "RAILS_ENV" => Rails.env.to_s }
-        argv = ["bundle", "exec", "rake", task.to_s]
-        stdout_and_stderr, status = Open3.capture2e(env, *argv, chdir: Rails.root.to_s)
-        <<~TEXT.strip
-          $ #{argv.join(' ')}
-          (exit #{status.exitstatus})
-
-          #{stdout_and_stderr}
-        TEXT
-      rescue Errno::ENOENT => e
-        <<~TEXT.strip
-          Failed to run command: #{e.message}
-        TEXT
-      end
-
-      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
-end

data/app/services/ruby_cms/security_tracker.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  # Tracks security events to Ahoy::Event for analytics and monitoring.
-  # Use from host app controllers: RubyCms::SecurityTracker.track(...)
-  #
-  # Example:
-  #   RubyCms::SecurityTracker.track("failed_login", description: "Invalid password", request: request)
-  class SecurityTracker
-    EVENT_TYPES = %w[
-      failed_login
-      successful_login
-      logout
-      admin_access_denied
-      suspicious_user_agent
-      unusual_request_pattern
-      session_hijack_attempt
-      rate_limit_exceeded
-      csrf_token_mismatch
-      unauthorized_admin_attempt
-      contact_honeypot_triggered
-      contact_blocked_email_attempt
-      email_blocklist_error
-      ip_blocklist_error
-      ip_blocklist_blocked
-    ].freeze
-
-    def self.track(event_type, description:, user: nil, request: nil, ip_address: nil,
-                   user_agent: nil, request_path: nil)
-      return nil unless EVENT_TYPES.include?(event_type)
-
-      attrs = {
-        name: event_type,
-        ip_address: ip_address || request&.remote_ip,
-        request_path: request_path || request&.path,
-        user_agent: user_agent || request&.user_agent,
-        properties: { description: },
-        time: Time.current,
-        user: user
-      }
-
-      Ahoy::Event.create!(**attrs)
-    rescue StandardError => e
-      Rails.logger.error "Failed to track security event: #{e.message}"
-      nil
-    end
-
-    def self.risk_level(event_type)
-      case event_type
-      when "session_hijack_attempt", "unauthorized_admin_attempt" then "high"
-      when "failed_login", "csrf_token_mismatch" then "medium"
-      when "successful_login", "logout" then "info"
-      else "low"
-      end
-    end
-
-    def self.risk_color(event_type)
-      case risk_level(event_type)
-      when "high" then "red"
-      when "medium" then "yellow"
-      when "info" then "green"
-      else "blue"
-      end
-    end
-
-    def self.formatted_description(event)
-      event_type = event.name
-      ip = event.ip_address
-      user_agent = event.user_agent
-      path = event.request_path
-      description = event.properties&.dig("description") || event.try(:description)
-
-      case event_type
-      when "failed_login" then "Failed login attempt from #{ip}"
-      when "successful_login" then "Successful admin login from #{ip}"
-      when "logout" then "Admin logout from #{ip}"
-      when "admin_access_denied" then "Unauthorized admin access attempt from #{ip}"
-      when "unauthorized_admin_attempt" then "Non-admin user attempted admin login"
-      when "suspicious_user_agent" then "Suspicious user agent: #{user_agent&.truncate(50)}"
-      when "unusual_request_pattern" then "Unusual request pattern: #{path}"
-      when "session_hijack_attempt" then "Potential session hijacking from #{ip}"
-      when "rate_limit_exceeded" then "Rate limit exceeded from #{ip}"
-      when "csrf_token_mismatch" then "CSRF token mismatch on #{path}"
-      when "contact_honeypot_triggered" then "Contact honeypot triggered from #{ip}"
-      when "contact_blocked_email_attempt" then "Blocked contact email: #{description}"
-      when "email_blocklist_error" then "Error adding email to blocklist: #{description}"
-      when "ip_blocklist_blocked" then "Blocked IP #{ip} attempting #{path}"
-      else description.presence || event_type.humanize
-      end
-    end
-  end
-end

data/app/views/admin/content_block_versions/index.html.erb

@@ -1,52 +0,0 @@
-<h1>Versiegeschiedenis: <%= @content_block.key %></h1>
-
-<%= link_to "Terug naar content block", ruby_cms_admin_content_block_path(@content_block),
-    class: "inline-flex items-center gap-1 text-sm text-muted-foreground hover:text-foreground mb-4" %>
-
-<div class="space-y-4">
-  <% @versions.each do |version| %>
-    <div class="rounded-lg border border-border/60 bg-card p-4">
-      <div class="flex items-center justify-between">
-        <div class="flex items-center gap-3">
-          <span class="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium
-            <%= case version.event
-                when 'create' then 'bg-blue-50 text-blue-700 ring-1 ring-blue-200'
-                when 'update' then 'bg-amber-50 text-amber-700 ring-1 ring-amber-200'
-                when 'rollback' then 'bg-purple-50 text-purple-700 ring-1 ring-purple-200'
-                when 'publish' then 'bg-emerald-50 text-emerald-700 ring-1 ring-emerald-200'
-                when 'unpublish' then 'bg-red-50 text-red-700 ring-1 ring-red-200'
-                when 'visual_editor' then 'bg-cyan-50 text-cyan-700 ring-1 ring-cyan-200'
-                else 'bg-muted text-muted-foreground ring-1 ring-border/60'
-                end %>">
-            v<%= version.version_number %> — <%= version.event %>
-          </span>
-          <span class="text-sm text-muted-foreground">
-            <%= version.user&.name || version.user&.email || "System" %>
-          </span>
-          <span class="text-xs text-muted-foreground">
-            <%= version.created_at.strftime("%b %d, %Y %H:%M") %>
-          </span>
-        </div>
-
-        <div class="flex items-center gap-2">
-          <%= link_to "Bekijk diff", ruby_cms_admin_content_block_version_path(@content_block, version),
-              class: "text-xs text-primary hover:underline" %>
-
-          <% unless version == @versions.first %>
-            <%= button_to "Rollback",
-                rollback_ruby_cms_admin_content_block_version_path(@content_block, version),
-                method: :post,
-                data: { turbo_confirm: "Weet je zeker dat je wilt terugdraaien naar versie #{version.version_number}?" },
-                class: "text-xs text-destructive hover:underline" %>
-          <% end %>
-        </div>
-      </div>
-
-      <% if version.metadata&.dig("changed_fields").present? %>
-        <p class="mt-2 text-xs text-muted-foreground">
-          Gewijzigde velden: <%= version.metadata["changed_fields"].join(", ") %>
-        </p>
-      <% end %>
-    </div>
-  <% end %>
-</div>