yummy-guide-generic-administrate 0.1.0

data/app/assets/stylesheets/yummy_guide_administrate/components.scss

@@ -0,0 +1,199 @@
+.scroll-table {
+  overflow-x: auto;
+}
+
+.scroll-table table th.sticky-left,
+.scroll-table table td.sticky-left {
+  position: sticky;
+  background-clip: padding-box;
+}
+
+.scroll-table table th.sticky-left {
+  z-index: 4;
+  background-color: #121012;
+}
+
+.scroll-table table td.sticky-left {
+  z-index: 3;
+  background-color: var(--sticky-cell-background, #fff);
+}
+
+.scroll-table table th.sticky-left::after,
+.scroll-table table td.sticky-left::after {
+  content: "";
+  position: absolute;
+  top: -1px;
+  right: -1px;
+  bottom: -1px;
+  width: 1px;
+  background-color: #fff;
+  pointer-events: none;
+}
+
+.scroll-table table th.sticky-left--last,
+.scroll-table table td.sticky-left--last {
+  box-shadow: 6px 0 8px -8px rgba(0, 0, 0, 0.35);
+}
+
+.yummy-guide-administrate-filter-form {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+  background: #fff;
+  border: 1px solid #d7dce5;
+  border-radius: 12px;
+  box-shadow: 0 18px 44px rgba(15, 23, 42, 0.08);
+  overflow: hidden;
+}
+
+.yummy-guide-administrate-filter-form__title {
+  margin: 0;
+  padding: 20px 20px 16px;
+  font-size: 1.2rem;
+}
+
+.yummy-guide-administrate-filter-form__body {
+  padding: 0 20px;
+}
+
+.yummy-guide-administrate-filter-form .filter_table {
+  width: 100%;
+}
+
+.yummy-guide-administrate-filter-form .filter_table td {
+  padding: 8px 0;
+  vertical-align: top;
+}
+
+.yummy-guide-administrate-filter-form .filter_table td:first-child {
+  width: 160px;
+  font-weight: 600;
+  vertical-align: middle;
+}
+
+.yummy-guide-administrate-filter-form input[type="text"],
+.yummy-guide-administrate-filter-form input[type="date"],
+.yummy-guide-administrate-filter-form select,
+.yummy-guide-administrate-filter-form textarea,
+.yummy-guide-administrate-filter-form .filter-datetime-group__time {
+  width: 100%;
+  min-height: 40px;
+  height: 40px;
+  box-sizing: border-box;
+  border: 1px solid #dfe0e1;
+  border-radius: 5px;
+  background-color: #fff;
+}
+
+.yummy-guide-administrate-filter-form__actions {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+  align-items: center;
+  flex-wrap: wrap;
+  padding: 12px 20px 20px;
+  background: #fff;
+  border-top: 1px solid #e5e7eb;
+  box-shadow: 0 -12px 24px rgba(15, 23, 42, 0.08);
+}
+
+.filter-datetime-group {
+  display: grid;
+  grid-template-columns: minmax(180px, 1fr) 88px auto 88px;
+  gap: 8px;
+  align-items: center;
+}
+
+.filter-datetime-group__separator,
+.filter-datetime-range-separator {
+  text-align: center;
+  margin: 0;
+  min-height: 40px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.filter-checkbox-group {
+  display: grid;
+  gap: 12px;
+}
+
+.filter-checkbox-group__options {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+  gap: 8px 12px;
+}
+
+.filter-checkbox-group__actions {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+  align-items: center;
+  flex-wrap: wrap;
+}
+
+.json-pretty-field {
+  margin: 0;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+
+.yummy-guide-administrate-picture-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.yummy-guide-administrate-picture-list__item {
+  width: 200px;
+}
+
+.yummy-guide-administrate-picture-list__image {
+  display: block;
+  max-width: 100%;
+  border-radius: 8px;
+}
+
+.yummy-guide-administrate-picture-slots {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+  gap: 12px;
+}
+
+.yummy-guide-administrate-picture-slot {
+  display: grid;
+  gap: 8px;
+  align-content: start;
+}
+
+.yummy-guide-administrate-picture-slot__input {
+  width: 100%;
+}
+
+.yummy-guide-administrate-picture-slot__delete {
+  display: inline-flex;
+  gap: 6px;
+  align-items: center;
+}
+
+@media (max-width: 767px) {
+  .yummy-guide-administrate-filter-form__title {
+    padding: 16px 16px 12px;
+  }
+
+  .yummy-guide-administrate-filter-form__body {
+    padding: 0 16px;
+  }
+
+  .yummy-guide-administrate-filter-form__actions,
+  .filter-checkbox-group__actions {
+    flex-direction: column;
+    align-items: stretch;
+  }
+
+  .filter-datetime-group {
+    grid-template-columns: 1fr;
+  }
+}
+

data/app/controllers/concerns/yummy_guide/administrate/datetime_filter_parameters.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module YummyGuide
+  module Administrate
+    module DatetimeFilterParameters
+      extend ActiveSupport::Concern
+
+      private
+
+      def normalize_datetime_filter_params(filters, keys:)
+        return filters if filters.blank? || !filters.respond_to?(:deep_dup)
+
+        normalized_filters = filters.deep_dup
+
+        Array(keys).map(&:to_s).each do |key|
+          date_value = normalized_filters.delete("#{key}_date") || normalized_filters.delete("#{key}_date".to_sym)
+          hour_value = normalized_filters.delete("#{key}_hour") || normalized_filters.delete("#{key}_hour".to_sym)
+          minute_value = normalized_filters.delete("#{key}_minute") || normalized_filters.delete("#{key}_minute".to_sym)
+          next if date_value.nil? && hour_value.nil? && minute_value.nil?
+
+          date_value = date_value.to_s.strip
+          hour_value = hour_value.to_s.strip
+          minute_value = minute_value.to_s.strip
+
+          normalized_filters[key.to_sym] =
+            if date_value.blank?
+              nil
+            elsif hour_value.present? && minute_value.present?
+              "#{date_value}T#{hour_value}:#{minute_value}"
+            else
+              date_value
+            end
+        end
+
+        normalized_filters
+      end
+    end
+  end
+end
+

data/app/controllers/concerns/yummy_guide/administrate/default_sorting.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module YummyGuide
+  module Administrate
+    module DefaultSorting
+      extend ActiveSupport::Concern
+
+      def default_sorting_attribute
+        dashboard_sorting_value(:default_sorting_attribute) || super
+      end
+
+      def default_sorting_direction
+        dashboard_sorting_value(:default_sorting_direction) || super
+      end
+
+      private
+
+      def sorting_requested?
+        order_present?(params) || sorting_param_keys.any? { |key| order_present?(params[key]) }
+      end
+
+      def dashboard_sorting_value(method_name)
+        current_dashboard = dashboard
+        return unless current_dashboard.respond_to?(method_name)
+
+        current_dashboard.public_send(method_name)
+      end
+
+      def sorting_param_keys
+        [
+          (resource_name if respond_to?(:resource_name, true)),
+          (resource_name.to_sym if respond_to?(:resource_name, true) && resource_name.present?),
+          controller_name.singularize,
+          controller_name.singularize.to_sym
+        ].compact.uniq
+      end
+
+      def order_present?(value)
+        return false unless value.is_a?(ActionController::Parameters) || value.is_a?(Hash)
+
+        value[:order].present? || value["order"].present?
+      end
+    end
+  end
+end
+

data/app/dashboards/yummy_guide/administrate/application_dashboard.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "administrate/base_dashboard"
+
+module YummyGuide
+  module Administrate
+    class ApplicationDashboard < ::Administrate::BaseDashboard
+      INDEX_FIXED_COLUMNS_COUNT = 1
+
+      def default_sorting_attribute
+        :created_at
+      end
+
+      def default_sorting_direction
+        :desc
+      end
+
+      def self.index_fixed_columns_count
+        if const_defined?(:INDEX_FIXED_COLUMNS_COUNT, false)
+          const_get(:INDEX_FIXED_COLUMNS_COUNT)
+        elsif superclass.respond_to?(:index_fixed_columns_count)
+          superclass.index_fixed_columns_count
+        else
+          0
+        end
+      end
+
+      def self.collection_sortable_attributes
+        if const_defined?(:COLLECTION_SORTABLE_ATTRIBUTES, false)
+          const_get(:COLLECTION_SORTABLE_ATTRIBUTES)
+        elsif const_defined?(:COLLECTION_ATTRIBUTES, false)
+          const_get(:COLLECTION_ATTRIBUTES)
+        elsif superclass.respond_to?(:collection_sortable_attributes)
+          superclass.collection_sortable_attributes
+        else
+          []
+        end
+      end
+
+      def self.collection_attribute_sortable?(attribute_name)
+        collection_sortable_attributes.map(&:to_sym).include?(attribute_name.to_sym)
+      end
+    end
+  end
+end
+

data/app/fields/yummy_guide/administrate/fields/area/picture_field.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "administrate/field/base"
+
+module YummyGuide
+  module Administrate
+    module Fields
+      module Area
+        class PictureField < ::Administrate::Field::Base
+          def self.field_type
+            "yummy_guide_administrate/area/picture"
+          end
+
+          def attachments
+            @attachments ||=
+              if data.respond_to?(:attachments)
+                data.attachments.to_a
+              elsif data.respond_to?(:attached?) && data.attached?
+                [data]
+              else
+                []
+              end
+          end
+
+          def max_uploads
+            resolved = resolve_option(:max_uploads)
+            resolved = resource.class::MAX_PICTURE_UPLOADS if resolved.blank? && resource.class.const_defined?(:MAX_PICTURE_UPLOADS)
+            resolved = attachments.size + 1 if resolved.blank?
+
+            [resolved.to_i, 1].max
+          end
+
+          def input_name
+            resolve_option(:input_name) || "#{resource_param_key}[#{attribute}][]"
+          end
+
+          def purge_input_name
+            resolve_option(:purge_input_name) || "#{resource_param_key}[#{attribute}_purge_ids][]"
+          end
+
+          def attachment_label(attachment)
+            return attachment.filename.to_s if attachment.respond_to?(:filename)
+
+            attachment.to_s
+          end
+
+          def attachment_identifier(attachment)
+            return attachment.id if attachment.respond_to?(:id) && attachment.id.present?
+            return attachment.blob_id if attachment.respond_to?(:blob_id) && attachment.blob_id.present?
+
+            nil
+          end
+
+          def attachment_url(attachment, view_context:)
+            resolve_attachment_url(:attachment_url, attachment, view_context: view_context) || preview_url(attachment, view_context: view_context)
+          end
+
+          def preview_url(attachment, view_context:)
+            resolve_attachment_url(:preview_url, attachment, view_context: view_context) || default_attachment_url(attachment, view_context: view_context)
+          end
+
+          private
+
+          def resource_param_key
+            resource.class.model_name.param_key
+          end
+
+          def resolve_option(name)
+            option = options[name]
+            if option.respond_to?(:call)
+              return option.call if option.arity.zero?
+              return option.call(resource) if option.arity == 1
+
+              return option.call(resource, attribute, data)
+            end
+
+            option
+          end
+
+          def resolve_attachment_url(name, attachment, view_context:)
+            resolver = options[name]
+            return unless resolver.respond_to?(:call)
+
+            case resolver.arity
+            when 0
+              resolver.call
+            when 1
+              resolver.call(attachment)
+            else
+              resolver.call(attachment, view_context)
+            end
+          end
+
+          def default_attachment_url(attachment, view_context:)
+            return attachment.url if attachment.respond_to?(:url)
+            return view_context.rails_blob_path(attachment, only_path: true) if attachment.respond_to?(:blob)
+
+            nil
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/app/fields/yummy_guide/administrate/fields/json_pretty_field.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "administrate/field/text"
+require "json"
+
+module YummyGuide
+  module Administrate
+    module Fields
+      class JsonPrettyField < ::Administrate::Field::Text
+        def self.field_type
+          "yummy_guide_administrate/json_pretty_field"
+        end
+
+        def to_s
+          return if data.blank?
+
+          if data.is_a?(String)
+            JSON.pretty_generate(JSON.parse(data))
+          else
+            JSON.pretty_generate(data.as_json)
+          end
+        rescue JSON::ParserError, TypeError
+          data.to_s
+        end
+      end
+    end
+  end
+end
+

data/app/fields/yummy_guide/administrate/fields/version_item_field.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module YummyGuide
+  module Administrate
+    module Fields
+      class VersionItemField < ::Administrate::Field::Base
+        def self.field_type
+          "yummy_guide_administrate/version_item_field"
+        end
+
+        def target_resource
+          @target_resource ||= resolve_target_resource
+        end
+
+        def label
+          target = target_resource
+          return fallback_label if target.blank?
+
+          "#{target.class.name.demodulize} ##{target.id}"
+        end
+
+        def path
+          return if target_resource.blank?
+
+          Rails.application.routes.url_helpers.polymorphic_path([namespace, target_resource])
+        rescue StandardError
+          nil
+        end
+
+        def linkable?
+          path.present?
+        end
+
+        private
+
+        def namespace
+          options.fetch(:namespace, :admin)
+        end
+
+        def resolve_target_resource
+          item = data.presence || resource.reify
+          normalize_resource(item)
+        rescue StandardError
+          nil
+        end
+
+        def normalize_resource(item)
+          return if item.blank?
+
+          return item.globalized_model if item.respond_to?(:globalized_model) && item.globalized_model.present?
+
+          item
+        end
+
+        def fallback_label
+          "#{resource.item_type} ##{resource.item_id}"
+        end
+      end
+    end
+  end
+end
+

data/app/fields/yummy_guide/administrate/fields/version_whodunnit_field.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module YummyGuide
+  module Administrate
+    module Fields
+      class VersionWhodunnitField < ::Administrate::Field::Base
+        def self.field_type
+          "yummy_guide_administrate/version_whodunnit_field"
+        end
+
+        def user
+          @user ||= user_class&.find_by(id: data)
+        end
+
+        def label
+          return if data.blank?
+
+          if user.present?
+            custom_label = options[:user_label]
+            return custom_label.call(user) if custom_label.respond_to?(:call)
+
+            if defined?(::UserDashboard)
+              dashboard = ::UserDashboard.new
+              return dashboard.display_resource(user) if dashboard.respond_to?(:display_resource)
+            end
+
+            return user.full_name if user.respond_to?(:full_name) && user.full_name.present?
+            return user.name if user.respond_to?(:name) && user.name.present?
+
+            "#{user.class.model_name.human} ##{user.id}"
+          else
+            "User ##{data}"
+          end
+        end
+
+        def path
+          return if user.blank?
+
+          Rails.application.routes.url_helpers.polymorphic_path([namespace, user])
+        rescue StandardError
+          nil
+        end
+
+        def linkable?
+          path.present?
+        end
+
+        private
+
+        def namespace
+          options.fetch(:namespace, :admin)
+        end
+
+        def user_class
+          candidate = options[:user_class]
+          return candidate if candidate.is_a?(Class)
+          return candidate.safe_constantize if candidate.respond_to?(:safe_constantize)
+
+          ::User if defined?(::User)
+        end
+      end
+    end
+  end
+end
+

data/app/helpers/yummy_guide/administrate/collection_helper.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module YummyGuide
+  module Administrate
+    module CollectionHelper
+      def yummy_guide_administrate_collection_table_fixed_columns_count(page:, collection_presenter:)
+        return 0 unless page.respond_to?(:instance_variable_defined?) && page.instance_variable_defined?(:@dashboard)
+
+        dashboard = page.instance_variable_get(:@dashboard)
+        return 0 unless dashboard&.class&.respond_to?(:index_fixed_columns_count)
+
+        fixed_columns_count = dashboard.class.index_fixed_columns_count.to_i
+        fixed_columns_count = 0 if fixed_columns_count.negative?
+
+        attribute_count = collection_presenter.attribute_types.size
+        [fixed_columns_count, attribute_count].min
+      rescue NoMethodError
+        0
+      end
+
+      def yummy_guide_administrate_collection_detail_path(resource, namespace:)
+        return if resource.blank?
+        return if respond_to?(:accessible_action?) && !accessible_action?(resource, :show)
+
+        polymorphic_path([namespace, resource])
+      rescue StandardError
+        nil
+      end
+
+      def yummy_guide_administrate_collection_attribute_path(attribute:, resource:, namespace:)
+        if yummy_guide_administrate_collection_reference_link?(attribute)
+          yummy_guide_administrate_collection_detail_path(attribute.data, namespace: namespace)
+        elsif yummy_guide_administrate_collection_text_link?(attribute)
+          yummy_guide_administrate_collection_detail_path(resource, namespace: namespace)
+        end
+      end
+
+      def yummy_guide_administrate_collection_reference_link?(attribute)
+        attribute.is_a?(::Administrate::Field::BelongsTo) && attribute.data.present?
+      end
+
+      def yummy_guide_administrate_collection_text_link?(attribute)
+        attribute.respond_to?(:name) && attribute.name.to_s == "id"
+      end
+
+      def yummy_guide_administrate_collection_wrap(content, href:)
+        return content if href.blank?
+
+        link_to(href, class: "action-show") { content }
+      end
+
+      def yummy_guide_administrate_collection_actions_partial(partial_name)
+        if controller.respond_to?(:controller_path)
+          controller_partial = "#{controller.controller_path}/#{partial_name}"
+          return controller_partial if lookup_context.exists?(controller_partial, [], true)
+        end
+
+        "administrate/application/#{partial_name}"
+      end
+    end
+  end
+end