activeadmin_favorites 0.1.0

data/app/models/active_admin/favorites/favorite.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    class Favorite < ApplicationRecord
+      include UserRecord
+
+      KINDS = %w[filters lens combined].freeze
+      ACTIONS = %w[index show].freeze
+
+      STI_TYPE_BY_KIND = {
+        "filters" => "ActiveAdmin::Favorites::FiltersFavorite",
+        "lens" => "ActiveAdmin::Favorites::LensFavorite",
+        "combined" => "ActiveAdmin::Favorites::CombinedFavorite"
+      }.freeze
+
+      KIND_BY_STI_TYPE = STI_TYPE_BY_KIND.invert.freeze
+
+      attribute :macros, :json, default: -> { [] }
+      attribute :layout, :json
+
+      attr_accessor :macros_json, :use_advanced_macros, :include_layout
+
+      validates :name, :resource_key, :path, presence: true
+      validates :published, inclusion: {in: [true, false]}
+      validates :macros_version, numericality: {only_integer: true, greater_than: 0}
+      validates :action, inclusion: {in: ACTIONS}, allow_nil: true
+
+      validate :path_starts_with_namespace_prefix
+      validate :unique_path_query_and_type_per_user
+      validate :validate_macros_schema
+
+      before_validation :normalize_blank_query_string
+
+      before_save :sync_published_at
+      before_validation :assign_default_type
+
+      scope :visible_to, ->(user) {
+        foreign_key = ActiveAdmin::Favorites.config.user_foreign_key
+        where(foreign_key => user).or(where(published: true))
+      }
+
+      scope :filters_kind, -> { where(type: FiltersFavorite.name) }
+      scope :lens_kind, -> { where(type: LensFavorite.name) }
+      scope :combined_kind, -> { where(type: CombinedFavorite.name) }
+
+      def self.table_name
+        ActiveAdmin::Favorites.config.table_name
+      end
+
+      def self.model_name
+        @model_name ||= ActiveModel::Name.new(self, nil, "Favorite")
+      end
+
+      def self.policy_class
+        ActiveAdmin::Favorites::FavoritePolicy
+      end
+
+      def self.sti_class_for_kind(kind)
+        STI_TYPE_BY_KIND.fetch(kind.to_s).constantize
+      end
+
+      def self.kind_for_type(type_name)
+        KIND_BY_STI_TYPE.fetch(type_name)
+      end
+
+      def self.sanitize_query_string(raw_query_string)
+        return if raw_query_string.blank?
+
+        QueryParams.build(QueryParams.parse(raw_query_string))
+      end
+
+      def self.suggested_name(resource_key:, query_string:, kind: "filters")
+        label = resource_label_for(resource_key)
+        summary =
+          case kind
+          when "lens"
+            I18n.t("active_admin.favorites.lens_summary", default: "Page layout")
+          when "combined"
+            [filter_summary_for(query_string, macros: []), I18n.t("active_admin.favorites.lens_summary", default: "Page layout")].compact.join(" · ")
+          else
+            filter_summary_for(query_string, macros: [])
+          end
+        [label, summary].compact.join(" — ").truncate(120)
+      end
+
+      def self.resource_label_for(resource_key)
+        return resource_key.humanize if resource_key.blank?
+
+        config = active_admin_resource_for(resource_key)
+        config&.resource_label || resource_key.tr("_", " ").titleize
+      end
+
+      def self.filter_summary_for(query_string, macros: [])
+        params = QueryParams.parse(query_string)
+        parts = []
+        parts << "scope: #{params["scope"]}" if params["scope"].present?
+
+        macro_parts = Array(macros).map { |macro| MacroCatalog.describe(macro) }
+        parts.concat(macro_parts)
+
+        query_filters = params["q"]
+        if query_filters.is_a?(Hash) && query_filters.any?
+          parts << query_filters.keys.map { |key| key.sub(/_(eq|gteq|lteq|cont)\z/, "").tr("_", " ") }.join(", ")
+        end
+
+        parts << "sort: #{params["order"]}" if params["order"].present?
+        parts.join(" · ").presence
+      end
+
+      def self.ransackable_attributes_for(resource_key)
+        resource_class = resource_class_for(resource_key)
+        return [] unless resource_class
+
+        if resource_class.respond_to?(:ransackable_attributes)
+          resource_class.ransackable_attributes
+        else
+          []
+        end
+      end
+
+      def self.resource_class_for(resource_key)
+        active_admin_resource_for(resource_key)&.resource_class
+      end
+
+      def self.active_admin_resource_for(resource_key)
+        namespace = ActiveAdmin.application.namespace(ActiveAdmin::Favorites.config.namespace_name)
+        namespace.resources.find do |resource|
+          resource.is_a?(ActiveAdmin::Resource) && resource.resource_name.route_key == resource_key
+        end
+      end
+
+      def self.detected_ranges(query_string:, resource_key:)
+        RangeDetector.call(query_string:, resource_key:)
+      end
+
+      def self.macro_assignments_from_macros(macros)
+        Array(macros).filter_map do |macro|
+          next unless macro["type"] == "template"
+
+          {
+            "enabled" => "1",
+            "attribute" => macro["attribute"],
+            "name" => macro["name"]
+          }
+        end
+      end
+
+      def kind
+        self.class.kind_for_type(type)
+      end
+
+      def kind=(value)
+        self.type = self.class.sti_class_for_kind(value).name
+      end
+
+      def promote_to_kind!(value)
+        sti_class = self.class.sti_class_for_kind(value)
+        return self if is_a?(sti_class)
+
+        promoted = becomes(sti_class)
+        promoted.type = sti_class.name
+        promoted
+      end
+
+      def filter_summary
+        self.class.filter_summary_for(query_string, macros: macros)
+      end
+
+      def resource_label
+        self.class.resource_label_for(resource_key)
+      end
+
+      def layout_object
+        ViewLens::Layout.new(layout || {})
+      end
+
+      def resolved_query_string(at: Time.zone.now)
+        return query_string if macros.blank?
+
+        q_overrides = MacroResolver.call(macros: macros, at: at)
+        QueryParams.merge_query_string(query_string, q_overrides: q_overrides)
+      end
+
+      def index_url(at: Time.zone.now, favorite_id: nil)
+        resolved = resolved_query_string(at: at)
+        url = resolved.present? ? "#{path}?#{resolved}" : path
+        if favorite_id.present?
+          separator = url.include?("?") ? "&" : "?"
+          url = "#{url}#{separator}favorite_id=#{favorite_id}"
+        elsif id.present? && layout.present?
+          separator = url.include?("?") ? "&" : "?"
+          url = "#{url}#{separator}favorite_id=#{id}"
+        end
+        url
+      end
+
+      def show_url(favorite_id: nil)
+        return path if path.blank?
+
+        if favorite_id.present? || (id.present? && layout.present?)
+          favorite_param = favorite_id || id
+          "#{path}?favorite_id=#{favorite_param}"
+        else
+          path
+        end
+      end
+
+      def open_url(at: Time.zone.now)
+        if is_a?(LensFavorite)
+          (action == "show") ? show_url : index_url(at: at)
+        else
+          index_url(at: at)
+        end
+      end
+
+      def detected_ranges
+        self.class.detected_ranges(query_string:, resource_key: resource_key)
+      end
+
+      def macro_form_rows
+        rows_by_attribute = {}
+
+        detected_ranges.each do |range|
+          rows_by_attribute[range[:attribute]] = {
+            attribute: range[:attribute],
+            gteq: range[:gteq],
+            lteq: range[:lteq],
+            enabled: false,
+            name: "previous_calendar_month"
+          }
+        end
+
+        Array(macros).each do |macro|
+          next unless macro["type"] == "template"
+
+          attribute = macro["attribute"]
+          rows_by_attribute[attribute] ||= {attribute: attribute}
+          rows_by_attribute[attribute][:enabled] = true
+          rows_by_attribute[attribute][:name] = macro["name"]
+        end
+
+        rows_by_attribute.values
+      end
+
+      def macros_json_for_form
+        macros_json.presence || JSON.pretty_generate(macros)
+      end
+
+      def owned_by?(user)
+        public_send(:"#{ActiveAdmin::Favorites.config.user_foreign_key}") == user.id
+      end
+
+      def assign_macros_from_form!(template_assignments:, macros_json:, use_advanced_macros:)
+        parsed_macros =
+          if ActiveModel::Type::Boolean.new.cast(use_advanced_macros) && macros_json.present?
+            MacroBuilder.from_json(macros_json)
+          else
+            MacroBuilder.from_template_assignments(template_assignments)
+          end
+
+        self.macros = parsed_macros
+        MacroValidator.validate!(macros, resource_key: resource_key)
+        strip_query_string_for_macros!
+        true
+      rescue JSON::ParserError
+        errors.add(:macros_json, I18n.t("active_admin.favorites.macros_json_invalid"))
+        false
+      rescue MacroValidator::ValidationError => error
+        errors.add(:macros, error.message)
+        false
+      end
+
+      def kind_label
+        I18n.t("active_admin.favorites.kinds.#{kind}", default: kind.humanize)
+      end
+
+      private
+
+      def assign_default_type
+        self.type = FiltersFavorite.name if type.blank?
+      end
+
+      def path_starts_with_namespace_prefix
+        return if path.blank?
+
+        prefix = ActiveAdmin::Favorites.config.namespace_path_prefix
+        return if path.start_with?(prefix)
+
+        errors.add(:path, I18n.t("active_admin.favorites.errors.path_namespace", default: "must stay within the configured admin area"))
+      end
+
+      def normalize_blank_query_string
+        self.query_string = "" if query_string.nil?
+      end
+
+      def unique_path_query_and_type_per_user
+        foreign_key = ActiveAdmin::Favorites.config.user_foreign_key
+        owner_id = public_send(foreign_key)
+        return if owner_id.blank? || path.blank?
+
+        scope = self.class.where(
+          path: path,
+          query_string: query_string_for_uniqueness,
+          type: type
+        )
+        scope = scope.where(foreign_key => owner_id)
+        scope = scope.where.not(id: id) if persisted?
+
+        return unless scope.exists?
+
+        errors.add(:base, I18n.t("active_admin.favorites.errors.duplicate_favorite", default: "already saved for this page and filters"))
+      end
+
+      def query_string_for_uniqueness
+        query_string.presence || ""
+      end
+
+      def strip_query_string_for_macros!
+        keys = QueryParams.q_keys_for_macros(macros)
+        self.query_string = QueryParams.without_q_keys(query_string, keys: keys)
+      end
+
+      def validate_macros_schema
+        MacroValidator.validate!(macros, resource_key: resource_key)
+      rescue MacroValidator::ValidationError => error
+        errors.add(:macros, error.message)
+      end
+
+      def sync_published_at
+        if published?
+          self.published_at = Time.current if published_at.nil? || will_save_change_to_published?
+        else
+          self.published_at = nil
+        end
+      end
+    end
+  end
+end

data/app/models/active_admin/favorites/filters_favorite.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    class FiltersFavorite < Favorite
+    end
+  end
+end

data/app/models/active_admin/favorites/lens_favorite.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    class LensFavorite < Favorite
+      validates :layout, presence: true
+    end
+  end
+end

data/app/models/active_admin/favorites/view_lens/layout.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    module ViewLens
+      class Layout
+        VERSION = 1
+
+        def self.normalize(raw_layout)
+          layout = raw_layout.is_a?(Hash) ? raw_layout.deep_stringify_keys : {}
+          hidden = layout.fetch("hidden", {})
+          {
+            "version" => layout.fetch("version", VERSION),
+            "hidden" => {
+              "columns" => Array(hidden["columns"]).map(&:to_s),
+              "filters" => Array(hidden["filters"]).map(&:to_s),
+              "action_items" => Array(hidden["action_items"]).map(&:to_s),
+              "panels" => Array(hidden["panels"]).map(&:to_s),
+              "show_rows" => Array(hidden["show_rows"]).map(&:to_s)
+            }
+          }
+        end
+
+        def self.empty
+          new({})
+        end
+
+        def initialize(raw_layout)
+          @layout = self.class.normalize(raw_layout)
+        end
+
+        attr_reader :layout
+
+        def hidden_columns
+          @layout.dig("hidden", "columns")
+        end
+
+        def hidden_filters
+          @layout.dig("hidden", "filters")
+        end
+
+        def hidden_action_items
+          @layout.dig("hidden", "action_items")
+        end
+
+        def hidden_panels
+          @layout.dig("hidden", "panels")
+        end
+
+        def hidden_show_rows
+          @layout.dig("hidden", "show_rows")
+        end
+
+        def hidden_column?(column_id)
+          column_id.present? && hidden_columns.include?(column_id.to_s)
+        end
+
+        def hidden_filter?(filter_id)
+          filter_id.present? && hidden_filters.include?(filter_id.to_s)
+        end
+
+        def hidden_action_item?(action_name)
+          action_name.present? && hidden_action_items.include?(action_name.to_s)
+        end
+
+        def hidden_panel?(panel_id)
+          panel_id.present? && hidden_panels.include?(panel_id.to_s)
+        end
+
+        def hidden_show_row?(row_id)
+          row_id.present? && hidden_show_rows.include?(row_id.to_s)
+        end
+
+        def merge(other)
+          return self if other.blank?
+
+          other_layout = self.class.normalize(other.layout || other)
+          merged_hidden = layout.fetch("hidden", {}).merge(other_layout.fetch("hidden", {})) do |_key, left, right|
+            (left + right).uniq
+          end
+          self.class.new("version" => VERSION, "hidden" => merged_hidden)
+        end
+      end
+    end
+  end
+end

data/app/models/active_admin/favorites/view_lens_default.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    class ViewLensDefault < ApplicationRecord
+      include UserRecord
+
+      self.table_name = "active_admin_view_lens_defaults"
+
+      attribute :layout, :json, default: -> { ViewLens::Layout.empty.layout }
+
+      validates :resource_key, :action, presence: true
+      validates :action, inclusion: {in: %w[index show]}
+      validates :resource_key, uniqueness: {scope: [ActiveAdmin::Favorites.config.user_foreign_key, :action]}
+
+      def self.for_user(user, resource_key:, action:)
+        find_by(user_foreign_key_column => user.id, :resource_key => resource_key, :action => action)
+      end
+
+      def self.user_foreign_key_column
+        ActiveAdmin::Favorites.config.user_foreign_key
+      end
+
+      def self.upsert_for!(user:, resource_key:, action:, layout:)
+        record = find_or_initialize_by(
+          user_foreign_key_column => user.id,
+          :resource_key => resource_key,
+          :action => action
+        )
+        record.layout = ViewLens::Layout.normalize(layout)
+        record.save!
+        record
+      end
+
+      def layout_object
+        ViewLens::Layout.new(layout)
+      end
+    end
+  end
+end

data/app/models/active_admin/favorites.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+  end
+end

data/app/views/active_admin/favorites/_lens_catalog_data.html.erb

@@ -0,0 +1,9 @@
+<% catalog_payload = ActiveAdmin::Favorites::ViewLens::Applicator.catalog_payload(
+  active_admin_config: active_admin_config,
+  action: action_name,
+  render_context: local_assigns.fetch(:render_context) { self }
+) %>
+<script
+  type="application/json"
+  id="favorites-lens-catalog-<%= active_admin_config.resource_name.route_key %>-<%= action_name %>"
+><%= catalog_payload.to_json %></script>

data/app/views/active_admin/favorites/_macro_fields.html.erb

@@ -0,0 +1,53 @@
+<% bookmark = f.object %>
+<% template_options = ActiveAdmin::Favorites::Favorite::MacroCatalog.options_for_select %>
+<%= hidden_field_tag :macro_form_submitted, "1" %>
+
+<fieldset class="inputs">
+  <legend><span><%= t("active_admin.favorites.macros_panel") %></span></legend>
+  <p class="inline-hints"><%= t("active_admin.favorites.macros_hint") %></p>
+
+  <% if bookmark.macro_form_rows.any? %>
+    <ol class="space-y-4 list-none p-0">
+      <% bookmark.macro_form_rows.each_with_index do |row, index| %>
+        <li class="rounded-md border border-gray-200 p-4 dark:border-white/10">
+          <div class="font-medium text-sm mb-2">
+            <%= row[:attribute].to_s.tr("_", " ") %>
+            <% if row[:gteq].present? || row[:lteq].present? %>
+              <span class="text-gray-500">
+                (<%= [row[:gteq], row[:lteq]].compact.join(" – ") %>)
+              </span>
+            <% end %>
+          </div>
+          <%= hidden_field_tag "macro_template_assignments[#{index}][attribute]", row[:attribute] %>
+          <div class="flex flex-wrap items-center gap-4">
+            <label class="inline-flex items-center gap-2 text-sm">
+              <%= check_box_tag "macro_template_assignments[#{index}][enabled]", "1", row[:enabled], id: "macro_template_assignments_#{index}_enabled" %>
+              <%= t("active_admin.favorites.use_dynamic_range") %>
+            </label>
+            <%= select_tag "macro_template_assignments[#{index}][name]",
+              options_for_select(template_options, row[:name]),
+              id: "macro_template_assignments_#{index}_name",
+              class: "rounded-md border-gray-300 text-sm dark:border-white/20 dark:bg-gray-900" %>
+          </div>
+        </li>
+      <% end %>
+    </ol>
+  <% else %>
+    <p class="text-sm text-gray-600 dark:text-gray-300"><%= t("active_admin.favorites.no_detected_ranges") %></p>
+  <% end %>
+</fieldset>
+
+<details class="mt-6 rounded-md border border-gray-200 p-4 dark:border-white/10">
+  <summary class="cursor-pointer text-sm font-medium"><%= t("active_admin.favorites.advanced_macros") %></summary>
+  <div class="mt-4 space-y-3">
+    <label class="inline-flex items-center gap-2 text-sm">
+      <%= check_box_tag "favorite[use_advanced_macros]", "1", bookmark.use_advanced_macros, id: "favorite_use_advanced_macros" %>
+      <%= t("active_admin.favorites.use_advanced_macros") %>
+    </label>
+    <%= text_area_tag "favorite[macros_json]", bookmark.macros_json_for_form,
+      rows: 10,
+      class: "w-full font-mono text-xs rounded-md border-gray-300 dark:border-white/20 dark:bg-gray-900",
+      spellcheck: false %>
+    <p class="text-xs text-gray-500"><%= t("active_admin.favorites.macros_json_hint") %></p>
+  </div>
+</details>

data/app/views/active_admin/favorites/_personalization_trigger.html.erb

@@ -0,0 +1,69 @@
+<%
+  stimulus_controller = ActiveAdmin::Favorites.config.stimulus_controller
+  layout = active_admin_favorites_layout
+  resource_key = active_admin_config.resource_name.route_key
+  hidden = layout.layout.fetch("hidden", {})
+  catalog_element_id = "favorites-lens-catalog-#{resource_key}-#{action_name}"
+%>
+<div
+  class="relative"
+  data-controller="<%= stimulus_controller %>"
+  data-<%= stimulus_controller %>-resource-key-value="<%= resource_key %>"
+  data-<%= stimulus_controller %>-action-name-value="<%= action_name %>"
+  data-<%= stimulus_controller %>-path-value="<%= request.path %>"
+  data-<%= stimulus_controller %>-catalog-element-id-value="<%= catalog_element_id %>"
+  data-<%= stimulus_controller %>-hidden-value="<%= hidden.to_json %>"
+  data-<%= stimulus_controller %>-update-url-value="<%= admin_viewlenspreferences_update_path %>"
+  data-<%= stimulus_controller %>-reset-url-value="<%= admin_viewlenspreferences_reset_path %>"
+  data-<%= stimulus_controller %>-save-lens-url-value="<%= admin_viewlenspreferences_save_lens_favorite_path %>"
+  data-<%= stimulus_controller %>-favorites-url-value="<%= admin_favorites_path %>"
+  data-<%= stimulus_controller %>-group-labels-value="<%= {
+    columns: t("active_admin.favorites.groups.columns", default: "Columns"),
+    filters: t("active_admin.favorites.groups.filters", default: "Filters"),
+    action_items: t("active_admin.favorites.groups.action_items", default: "Actions"),
+    panels: t("active_admin.favorites.groups.panels", default: "Panels"),
+    show_rows: t("active_admin.favorites.groups.show_rows", default: "Rows")
+  }.to_json %>"
+  data-<%= stimulus_controller %>-empty-catalog-label-value="<%= t("active_admin.favorites.no_personalization_items") %>"
+>
+  <button
+    type="button"
+    class="action-item-button inline-flex items-center gap-2"
+    aria-label="<%= t("active_admin.favorites.personalize_page") %>"
+    data-dropdown-toggle="personalization-menu-<%= resource_key %>-<%= action_name %>"
+    data-dropdown-offset-distance="3"
+    data-dropdown-placement="bottom-end"
+    data-action="click-><%= stimulus_controller %>#prepareMenu"
+  >
+    <svg class="w-5 h-5" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor">
+      <path stroke-linecap="round" stroke-linejoin="round" d="M9.594 3.94c.09-.542.56-.94 1.11-.94h2.593c.55 0 1.02.398 1.11.94l.213 1.281c.063.374.313.686.645.87.074.04.147.083.22.127.325.196.72.257 1.075.124l1.217-.456a1.125 1.125 0 0 1 1.37.49l1.296 2.247a1.125 1.125 0 0 1-.26 1.431l-1.003.827c-.293.241-.438.613-.43.992a7.723 7.723 0 0 1 0 .255c-.008.378.137.75.43.991l1.004.827c.424.35.534.955.26 1.43l-1.298 2.247a1.125 1.125 0 0 1-1.369.491l-1.217-.456c-.355-.133-.75-.072-1.076.124a6.47 6.47 0 0 1-.22.128c-.331.183-.581.495-.644.869l-.213 1.281c-.09.543-.56.94-1.11.94h-2.594c-.55 0-1.019-.398-1.11-.94l-.213-1.281c-.062-.374-.312-.686-.644-.87a6.52 6.52 0 0 1-.22-.127c-.325-.196-.72-.257-1.075-.124l-1.217.456a1.125 1.125 0 0 1-1.369-.49l-1.297-2.247a1.125 1.125 0 0 1 .26-1.431l1.004-.827c.292-.24.437-.613.43-.991a6.932 6.932 0 0 1 0-.255c.007-.38-.138-.751-.43-.992l-1.004-.827a1.125 1.125 0 0 1-.26-1.43l1.297-2.247a1.125 1.125 0 0 1 1.37-.491l1.217.456c.356.133.751.072 1.076-.124.072-.044.146-.086.22-.128.332-.183.582-.495.644-.869l.214-1.28Z" />
+      <path stroke-linecap="round" stroke-linejoin="round" d="M15 12a3 3 0 1 1-6 0 3 3 0 0 1 6 0Z" />
+    </svg>
+    <span class="sr-only"><%= t("active_admin.favorites.personalize_page") %></span>
+  </button>
+
+  <div
+    id="personalization-menu-<%= resource_key %>-<%= action_name %>"
+    class="z-50 hidden w-80 max-w-[calc(100vw-2rem)] rounded-md bg-white p-4 shadow-lg ring-1 ring-black/5 dark:bg-gray-800 dark:ring-white/10"
+    role="region"
+    aria-label="<%= t("active_admin.favorites.personalization_region") %>"
+    data-<%= stimulus_controller %>-target="menu"
+  >
+    <h3 class="text-sm font-semibold mb-3"><%= t("active_admin.favorites.personalization_region") %></h3>
+
+    <div data-<%= stimulus_controller %>-target="catalogGroups"></div>
+
+    <div class="flex flex-col gap-2 border-t border-gray-200 pt-3 dark:border-white/10">
+      <button type="button" class="action-item-button w-full" data-action="<%= stimulus_controller %>#saveDefault">
+        <%= t("active_admin.favorites.save_default") %>
+      </button>
+      <button type="button" class="action-item-button w-full" data-action="<%= stimulus_controller %>#resetDefault">
+        <%= t("active_admin.favorites.reset_default") %>
+      </button>
+      <button type="button" class="action-item-button w-full" data-action="<%= stimulus_controller %>#saveLensFavorite">
+        <%= t("active_admin.favorites.save_lens_favorite") %>
+      </button>
+      <%= link_to t("active_admin.favorites.menu"), admin_favorites_path, class: "text-sm text-center no-underline hover:underline" %>
+    </div>
+  </div>
+</div>