activeadmin_favorites 0.1.0

data/lib/activeadmin/favorites/register_favorites.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    module RegisterFavorites
+      module_function
+
+      def call
+        return if resource_registered?
+
+        ActiveAdmin.register Favorite, as: "favorites" do
+          menu label: proc { I18n.t("active_admin.favorites.menu") }, priority: 2
+
+          actions :index, :new, :create, :edit, :update, :destroy
+
+          config.filters = false
+          config.sort_order = "created_at_desc"
+
+          permit_params :name, :note, :path, :query_string, :resource_key, :published, :macros_json,
+            :use_advanced_macros, :kind, :type, :action, :include_layout, layout: {}
+
+          controller do
+            helper_method :current_favorites_user, :favorites_kind_tab_active?
+
+            def current_favorites_user
+              send(ActiveAdmin::Favorites.config.current_user_method)
+            end
+
+            def build_new_resource
+              kind = params[:kind].presence || "filters"
+              resource = Favorite.sti_class_for_kind(kind).new
+              assign_new_favorite_defaults(resource)
+              resource
+            end
+
+            def build_resource
+              get_resource_ivar || begin
+                kind = params.dig(:favorite, :kind).presence || params[:kind].presence || "filters"
+                record = Favorite.sti_class_for_kind(kind).new
+                record = assign_attributes(record, resource_params)
+                authorize_resource!(record)
+                set_resource_ivar(record)
+              end
+            end
+
+            def create
+              build_resource
+              assign_favorite_owner(resource)
+              apply_macros_from_params(resource) if macro_form_submitted?
+              apply_layout_from_params(resource)
+
+              if resource.errors.any? || !resource.save
+                render :new, status: :unprocessable_entity
+              else
+                redirect_to admin_favorites_path(kind: resource.kind), notice: create_notice_for(resource)
+              end
+            end
+
+            def update
+              resource.assign_attributes(
+                permitted_params[:favorite].except(
+                  :macros_json, :use_advanced_macros, :include_layout, :layout, :kind,
+                  :path, :query_string, :resource_key, :action
+                )
+              )
+              apply_macros_from_params(resource) if macro_form_submitted?
+              apply_layout_from_params(resource)
+
+              if resource.errors.any? || !resource.save
+                render :edit, status: :unprocessable_entity
+              else
+                redirect_to admin_favorites_path(kind: resource.kind), notice: I18n.t("active_admin.favorites.updated")
+              end
+            end
+
+            def scoped_collection
+              association = ActiveAdmin::Favorites.config.user_association_name
+              scope = super.includes(association)
+              kind = params[:kind].presence
+              return scope if kind.blank?
+              return scope unless Favorite::KINDS.include?(kind)
+
+              scope.merge(Favorite.sti_class_for_kind(kind).all)
+            end
+
+            private
+
+            def assign_new_favorite_defaults(resource)
+              if params[:path].present?
+                resource.path = params[:path]
+                resource.query_string = Favorite.sanitize_query_string(params[:query_string])
+                resource.resource_key = params[:resource_key]
+              end
+              resource.action = params[:action_name] if params[:action_name].present?
+              resource.action ||= "index"
+              resource.kind = params[:kind] if params[:kind].present?
+
+              if resource.layout.blank? && resource.resource_key.present?
+                default = ViewLensDefault.for_user(
+                  current_favorites_user,
+                  resource_key: resource.resource_key,
+                  action: resource.action
+                )
+                resource.layout = default.layout if default
+              end
+
+              if resource.name.blank? && resource.resource_key.present?
+                resource.name = Favorite.suggested_name(
+                  resource_key: resource.resource_key,
+                  query_string: resource.query_string,
+                  kind: resource.kind
+                )
+              end
+
+              if ActiveModel::Type::Boolean.new.cast(params[:include_layout])
+                resource.layout = layout_from_params || resource.layout
+                if resource.kind == "filters" && resource.query_string.present? && resource.layout.present?
+                  resource = resource.promote_to_kind!("combined")
+                end
+              end
+            end
+
+            def assign_favorite_owner(resource)
+              resource.public_send(:"#{ActiveAdmin::Favorites.config.user_foreign_key}=", current_favorites_user.id)
+            end
+
+            def apply_macros_from_params(favorite)
+              favorite.use_advanced_macros = params.dig(:favorite, :use_advanced_macros)
+              favorite.macros_json = params.dig(:favorite, :macros_json)
+              favorite.assign_macros_from_form!(
+                template_assignments: params[:macro_template_assignments],
+                macros_json: favorite.macros_json,
+                use_advanced_macros: favorite.use_advanced_macros
+              )
+            end
+
+            def apply_layout_from_params(favorite)
+              return favorite unless ActiveModel::Type::Boolean.new.cast(params.dig(:favorite, :include_layout))
+
+              favorite.layout = layout_from_params || favorite.layout
+              if favorite.kind == "filters" && favorite.query_string.present? && favorite.layout.present?
+                favorite = favorite.promote_to_kind!("combined")
+                set_resource_ivar(favorite)
+              end
+              favorite
+            end
+
+            def layout_from_params
+              raw_layout = params.dig(:favorite, :layout)
+              return if raw_layout.blank?
+
+              parsed =
+                if raw_layout.is_a?(String)
+                  JSON.parse(raw_layout)
+                else
+                  raw_layout
+                end
+              ViewLens::Layout.normalize(parsed)
+            rescue JSON::ParserError
+              nil
+            end
+
+            def macro_form_submitted?
+              params[:macro_form_submitted].present?
+            end
+
+            def favorites_kind_tab_active?(kind)
+              if kind.nil?
+                params[:kind].blank?
+              else
+                params[:kind] == kind
+              end
+            end
+
+            def create_notice_for(resource)
+              case resource.kind
+              when "lens"
+                I18n.t("active_admin.favorites.lens_created")
+              when "combined"
+                I18n.t("active_admin.favorites.combined_created")
+              else
+                I18n.t("active_admin.favorites.created")
+              end
+            end
+          end
+
+          index title: proc { I18n.t("active_admin.favorites.title") } do
+            nav class: "flex flex-wrap gap-3 mb-4", "aria-label": I18n.t("active_admin.favorites.kind_navigation") do
+              link_to I18n.t("active_admin.favorites.kinds.all"),
+                admin_favorites_path,
+                class: favorites_kind_tab_active?(nil) ? "font-semibold underline" : "text-gray-600 dark:text-gray-300"
+              Favorite::KINDS.each do |kind|
+                link_to I18n.t("active_admin.favorites.kinds.#{kind}"),
+                  admin_favorites_path(kind: kind),
+                  class: favorites_kind_tab_active?(kind) ? "font-semibold underline" : "text-gray-600 dark:text-gray-300"
+              end
+            end
+
+            column :name do |favorite|
+              link_to favorite.name, favorite.open_url, class: "no-underline font-medium"
+            end
+            column I18n.t("active_admin.favorites.kind_column"), &:kind_label
+            column :resource, &:resource_label
+            column I18n.t("active_admin.favorites.filters_column") do |favorite|
+              (favorite.kind == "lens") ? "—" : favorite.filter_summary
+            end
+            column I18n.t("active_admin.favorites.visibility_column") do |favorite|
+              if favorite.published?
+                I18n.t("active_admin.favorites.visibility.published", time: l(favorite.published_at, default: "—"))
+              else
+                I18n.t("active_admin.favorites.visibility.mine")
+              end
+            end
+            column I18n.t("active_admin.favorites.creator_column") do |favorite|
+              next "—" if favorite.owned_by?(current_favorites_user)
+
+              owner = favorite.public_send(ActiveAdmin::Favorites.config.user_association_name)
+              label_method = ActiveAdmin::Favorites.config.user_label_method
+              owner&.public_send(label_method) || "—"
+            end
+            actions defaults: false do |favorite|
+              item I18n.t("active_admin.favorites.open"), favorite.open_url, class: "member_link"
+              if authorized?(:update, favorite)
+                item I18n.t("active_admin.edit"), edit_admin_favorite_path(favorite), class: "member_link"
+                item I18n.t("active_admin.delete"), admin_favorite_path(favorite),
+                  class: "member_link",
+                  method: :delete,
+                  data: {confirm: I18n.t("active_admin.delete_confirmation")}
+              end
+            end
+          end
+
+          form do |f|
+            f.semantic_errors(*f.object.errors.attribute_names)
+            f.inputs I18n.t("active_admin.favorites.form_panel") do
+              f.input :name, input_html: {autofocus: true}
+              f.input :note, as: :text, input_html: {rows: 3}
+              f.input :published, as: :boolean,
+                label: I18n.t("active_admin.favorites.published")
+              if f.object.new_record?
+                f.input :path, as: :hidden
+                f.input :query_string, as: :hidden
+                f.input :resource_key, as: :hidden
+                f.input :kind, as: :hidden
+                f.input :action, as: :hidden
+              end
+              if f.object.new_record? && f.object.kind == "filters"
+                f.input :include_layout, as: :boolean,
+                  label: I18n.t("active_admin.favorites.include_layout")
+                f.input :layout, as: :hidden,
+                  input_html: {value: (f.object.layout || {}).to_json}
+              end
+            end
+
+            if f.object.kind != "lens"
+              render partial: "active_admin/favorites/macro_fields", locals: {f: f}
+            end
+
+            f.actions
+          end
+
+          config.remove_action_item :new
+        end
+      end
+
+      def resource_registered?
+        ActiveAdmin.application.namespace(ActiveAdmin::Favorites.config.namespace_name)
+          .resources.any? { |resource| resource.resource_class == Favorite }
+      end
+    end
+  end
+end

data/lib/activeadmin/favorites/register_view_lens_preferences.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    module RegisterViewLensPreferences
+      PAGE_NAME = "ViewLensPreferences"
+
+      module_function
+
+      def parse_layout_param(raw_layout)
+        parsed =
+          if raw_layout.is_a?(String)
+            JSON.parse(raw_layout)
+          elsif raw_layout.respond_to?(:to_unsafe_h)
+            raw_layout.to_unsafe_h
+          else
+            raw_layout
+          end
+        ViewLens::Layout.normalize(parsed || {})
+      rescue JSON::ParserError
+        ViewLens::Layout.empty.layout
+      end
+
+      def call
+        return if page_registered?
+
+        ActiveAdmin.register_page PAGE_NAME, as: "view_lens_preferences" do
+          menu false
+
+          controller do
+            def layout_from_request
+              ActiveAdmin::Favorites::RegisterViewLensPreferences.parse_layout_param(params[:layout])
+            end
+
+            def authorize_view_lens_page_action!(action_name)
+              return unless respond_to?(:authorized?, true)
+
+              return if authorized?(action_name, active_admin_config)
+
+              redirect_to admin_root_path,
+                alert: I18n.t("active_admin.access_denied.message", default: "You are not authorized to perform this action.")
+            end
+          end
+
+          page_action :update, method: :patch do
+            authorize_view_lens_page_action!(:update)
+            user = send(ActiveAdmin::Favorites.config.current_user_method)
+            layout = ActiveAdmin::Favorites::RegisterViewLensPreferences.parse_layout_param(params[:layout])
+            ViewLensDefault.upsert_for!(
+              user: user,
+              resource_key: params.fetch(:resource_key),
+              action: params.fetch(:view_lens_action),
+              layout: layout
+            )
+            redirect_back fallback_location: admin_root_path, notice: I18n.t("active_admin.favorites.layout_saved")
+          end
+
+          page_action :reset, method: :delete do
+            authorize_view_lens_page_action!(:reset)
+            user = send(ActiveAdmin::Favorites.config.current_user_method)
+            record = ViewLensDefault.for_user(
+              user,
+              resource_key: params.fetch(:resource_key),
+              action: params.fetch(:view_lens_action)
+            )
+            record&.destroy
+            redirect_back fallback_location: admin_root_path, notice: I18n.t("active_admin.favorites.layout_reset")
+          end
+
+          page_action :save_lens_favorite, method: :post do
+            authorize_view_lens_page_action!(:save_lens_favorite)
+            user = send(ActiveAdmin::Favorites.config.current_user_method)
+            bookmark = LensFavorite.new(
+              name: params.fetch(:name),
+              resource_key: params.fetch(:resource_key),
+              path: params.fetch(:path),
+              action: params.fetch(:view_lens_action),
+              layout: ActiveAdmin::Favorites::RegisterViewLensPreferences.parse_layout_param(params[:layout]),
+              published: ActiveModel::Type::Boolean.new.cast(params[:published]) || false
+            )
+            bookmark.public_send(:"#{ActiveAdmin::Favorites.config.user_foreign_key}=", user.id)
+
+            if bookmark.save
+              redirect_to admin_favorites_path(kind: "lens"), notice: I18n.t("active_admin.favorites.lens_created")
+            else
+              redirect_back fallback_location: admin_root_path, alert: bookmark.errors.full_messages.to_sentence
+            end
+          end
+        end
+      end
+
+      def page_registered?
+        ActiveAdmin.application.namespace(ActiveAdmin::Favorites.config.namespace_name)
+          .resources.any? { |resource| resource.is_a?(ActiveAdmin::Page) && resource.name == PAGE_NAME }
+      end
+    end
+  end
+end

data/lib/activeadmin/favorites/user_record.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    module UserRecord
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def define_favorites_user_association!
+          return if favorites_user_association_defined?
+
+          config = ActiveAdmin::Favorites.config
+          belongs_to config.user_association_name,
+            class_name: config.user_class,
+            foreign_key: config.user_foreign_key
+
+          self.favorites_user_association_defined = true
+        end
+      end
+
+      included do
+        class_attribute :favorites_user_association_defined, instance_accessor: false, default: false
+      end
+    end
+  end
+end

data/lib/activeadmin/favorites/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    VERSION = "0.1.0"
+  end
+end

data/lib/activeadmin/favorites/view_lens/applicator.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    module ViewLens
+      class Applicator
+        class << self
+          def current_layout
+            value = Current.layout
+            return Layout.empty if value.nil?
+            return value if value.is_a?(Layout)
+
+            Layout.new(value)
+          end
+
+          def current_layout=(value)
+            Current.layout = value
+          end
+
+          def current_catalog
+            Current.catalog
+          end
+
+          def current_catalog=(value)
+            Current.catalog = value
+          end
+
+          def registered_columns
+            Current.registered_columns
+          end
+
+          def registered_panels
+            Current.registered_panels
+          end
+
+          def registered_rows
+            Current.registered_rows
+          end
+
+          def reset!
+            Current.reset
+          end
+
+          def resolve_layout(controller:)
+            user = controller.send(ActiveAdmin::Favorites.config.current_user_method)
+            config = controller.send(:active_admin_config)
+            action = controller.action_name
+            resource_key = config.resource_name.route_key
+
+            layout = ViewLens::Layout.empty
+            default = ViewLensDefault.for_user(user, resource_key: resource_key, action: action)
+            layout = layout.merge(default.layout_object) if default
+
+            favorite_id = controller.params[:favorite_id]
+            if favorite_id.present?
+              bookmark = Favorite.visible_to(user).find_by(id: favorite_id)
+              if bookmark&.layout.present? && bookmark.resource_key == resource_key && bookmark.action == action
+                layout = layout.merge(bookmark.layout_object)
+              end
+            end
+
+            Current.layout = layout
+            Current.catalog_context = {
+              active_admin_config: config,
+              action: action,
+              render_context: controller.helpers
+            }
+            layout
+          end
+
+          def build_catalog(active_admin_config:, action:, render_context: nil)
+            Catalog.for(
+              active_admin_config: active_admin_config,
+              action: action,
+              render_context: render_context
+            )
+          end
+
+          def catalog_payload(active_admin_config:, action:, render_context: nil)
+            build_catalog(
+              active_admin_config: active_admin_config,
+              action: action,
+              render_context: render_context
+            ).map do |entry|
+              {id: entry.id, label: entry.label, group: entry.group}
+            end
+          end
+
+          def register_column(resource_key:, id:, label:)
+            return if id.blank?
+
+            registered_columns[resource_key] << {id: id.to_s, label: label.to_s}
+          end
+
+          def register_panel(resource_key:, id:, label:)
+            return if id.blank?
+
+            registered_panels[resource_key] << {id: id.to_s, label: label.to_s}
+          end
+
+          def register_row(resource_key:, id:, label:)
+            return if id.blank?
+
+            registered_rows[resource_key] << {id: id.to_s, label: label.to_s}
+          end
+
+          def extract_column_id(args, resource_key: nil)
+            title = args[0]
+            return title.to_s if title.is_a?(Symbol)
+            return title.to_s.parameterize(separator: "_") if title.is_a?(String) && title.present?
+
+            options = args.last.is_a?(Hash) ? args.last : {}
+            return options[:lens_id].to_s if options[:lens_id].present?
+
+            next_block_column_id(resource_key) if resource_key.present?
+          end
+
+          def column_label_from_args(args, column_id:)
+            title = args[0]
+            options = args.last.is_a?(Hash) ? args.last : {}
+            return options[:label].to_s if options[:label].present?
+            return title.to_s.humanize if title.is_a?(Symbol)
+            return title if title.is_a?(String) && title.present?
+
+            if column_id.to_s.start_with?("block_column_")
+              position = column_id.to_s.delete_prefix("block_column_")
+              return I18n.t("active_admin.favorites.block_column", position: position, default: "Custom column %{position}")
+            end
+
+            column_id.to_s.humanize
+          end
+
+          def next_block_column_id(resource_key)
+            sequence = Current.block_column_sequence
+            sequence[resource_key] += 1
+            "block_column_#{sequence[resource_key]}"
+          end
+
+          def extract_panel_id(title, options)
+            options[:lens_id]&.to_s.presence || title.to_s.parameterize(separator: "_")
+          end
+
+          def extract_row_id(title, options)
+            options[:lens_id]&.to_s.presence || title.to_s.parameterize(separator: "_")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activeadmin/favorites/view_lens/catalog.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    module ViewLens
+      class Catalog
+        Entry = Data.define(:id, :label, :group)
+
+        def self.for(active_admin_config:, action:, render_context: nil)
+          new(active_admin_config:, action:, render_context:).call
+        end
+
+        def initialize(active_admin_config:, action:, render_context: nil)
+          @active_admin_config = active_admin_config
+          @action = action.to_s
+          @render_context = render_context
+        end
+
+        def call
+          case @action
+          when "index"
+            index_entries
+          when "show"
+            show_entries
+          else
+            []
+          end
+        end
+
+        private
+
+        def index_entries
+          entries = []
+          entries.concat(column_entries)
+          entries.concat(filter_entries)
+          entries.concat(action_item_entries(:index))
+          entries
+        end
+
+        def show_entries
+          entries = []
+          entries.concat(panel_entries)
+          entries.concat(row_entries)
+          entries.concat(action_item_entries(:show))
+          entries
+        end
+
+        def column_entries
+          registered = ViewLens::Applicator.registered_columns[@active_admin_config.resource_name.route_key] || []
+          registered.map do |column|
+            Entry.new(
+              id: column[:id],
+              label: column[:label],
+              group: "columns"
+            )
+          end
+        end
+
+        def filter_entries
+          return [] unless @active_admin_config.filters_enabled?
+
+          filters = @active_admin_config.filters
+          return [] if filters.blank?
+
+          filters.keys.map do |filter_key|
+            filter = @active_admin_config.filters[filter_key]
+            label = filter[:label] || filter_key.to_s.titleize
+            Entry.new(id: filter_key.to_s, label: label.to_s, group: "filters")
+          end
+        end
+
+        def action_item_entries(action)
+          action_items = @active_admin_config.action_items
+          return [] if action_items.blank?
+
+          action_items
+            .select { |item| item.display_on?(action, @render_context) }
+            .reject { |item| item.name.to_s.start_with?("personalize_page") }
+            .map do |item|
+              Entry.new(
+                id: item.name.to_s,
+                label: I18n.t("active_admin.favorites.action_items.#{item.name}", default: item.name.to_s.humanize),
+                group: "action_items"
+              )
+            end
+        end
+
+        def panel_entries
+          registered = ViewLens::Applicator.registered_panels[@active_admin_config.resource_name.route_key] || []
+          registered.map do |panel|
+            Entry.new(id: panel[:id], label: panel[:label], group: "panels")
+          end
+        end
+
+        def row_entries
+          registered = ViewLens::Applicator.registered_rows[@active_admin_config.resource_name.route_key] || []
+          registered.map do |row|
+            Entry.new(id: row[:id], label: row[:label], group: "show_rows")
+          end
+        end
+
+        def self.grouped(entries)
+          entries.group_by(&:group)
+        end
+      end
+    end
+  end
+end

data/lib/activeadmin/favorites/view_lens/current.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    module ViewLens
+      class Current < ActiveSupport::CurrentAttributes
+        attribute :layout, :catalog, :catalog_context
+        attribute :registered_columns, :registered_panels, :registered_rows, :block_column_sequence
+
+        def registered_columns
+          super || self.registered_columns = Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        def registered_panels
+          super || self.registered_panels = Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        def registered_rows
+          super || self.registered_rows = Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        def block_column_sequence
+          super || self.block_column_sequence = Hash.new(0)
+        end
+      end
+    end
+  end
+end