alchemy_cms 7.4.7 → 8.0.0.a

data/app/components/alchemy/admin/toolbar_button.rb

@@ -33,7 +33,7 @@ module Alchemy
     #
     class ToolbarButton < ViewComponent::Base
       erb_template <<-ERB
-        <div class="toolbar_button">
+        <div class="toolbar_button" id="<%= id %>">
           <sl-tooltip content="<%= label %>" placement="<%= tooltip_placement %>">
             <%= link_to(render_icon(icon, style: icon_style), url, {
               class: css_classes,
@@ -57,6 +57,7 @@ module Alchemy
         :if_permitted_to,
         :active,
         :link_options,
+        :id,
         :icon_style,
         :tooltip_placement
 
@@ -72,6 +73,7 @@ module Alchemy
         if_permitted_to: [],
         active: false,
         link_options: {},
+        id: nil,
         icon_style: "line",
         tooltip_placement: "top-start"
       )
@@ -85,6 +87,7 @@ module Alchemy
         @if_permitted_to = if_permitted_to
         @active = active
         @link_options = link_options
+        @id = id
         @icon_style = icon_style
         @tooltip_placement = tooltip_placement
       end
@@ -100,7 +103,7 @@ module Alchemy
       def permission_options = if_permitted_to.presence || permissions_from_url
 
       def permissions_from_url
-        action_controller = url.gsub(/\A\//, "").split("/")
+        action_controller = url.delete_prefix("/").split("/")
         [
           action_controller.last.to_sym,
           action_controller[0..action_controller.length - 2].join("_").to_sym

data/app/components/alchemy/ingredients/number_view.rb

@@ -0,0 +1,18 @@
+module Alchemy
+  module Ingredients
+    class NumberView < BaseView
+      def initialize(ingredient, options = {})
+        super(ingredient)
+        @options = {
+          units: {
+            unit: settings_value(:unit, value: options[:unit])
+          }.merge(options[:units] || {})
+        }
+      end
+
+      def call
+        number_to_human(value, @options)
+      end
+    end
+  end
+end

data/app/controllers/alchemy/admin/attachments_controller.rb

@@ -6,6 +6,12 @@ module Alchemy
       include UploaderResponses
       include ArchiveOverlay
 
+      add_alchemy_filter :by_file_type, type: :select,
+        options: -> { Alchemy::Attachment.file_types(_1.result) }
+      add_alchemy_filter :recent, type: :checkbox
+      add_alchemy_filter :last_upload, type: :checkbox
+      add_alchemy_filter :without_tag, type: :checkbox
+
       helper "alchemy/admin/tags"
 
       before_action(only: :assign) do
@@ -21,10 +27,6 @@ module Alchemy
           @attachments = @attachments.tagged_with(search_filter_params[:tagged_with])
         end
 
-        if search_filter_params[:filter].present?
-          @attachments = apply_filters(@attachments)
-        end
-
         @attachments = @attachments
           .page(params[:page] || 1)
           .per(items_per_page)
@@ -58,18 +60,9 @@ module Alchemy
       end
 
       def destroy
-        name = @attachment.name
         @attachment.destroy
-        @url = admin_attachments_url(search_filter_params)
-        flash[:notice] = Alchemy.t("File deleted successfully", name: name)
-      end
-
-      def download
-        @attachment = Attachment.find(params[:id])
-        send_file @attachment.file.path, {
-          filename: @attachment.file_name,
-          type: @attachment.file_mime_type
-        }
+        flash[:notice] = Alchemy.t("File deleted successfully", name: @attachment.name)
+        redirect_to alchemy.admin_attachments_path(**search_filter_params)
       end
 
       private

data/app/controllers/alchemy/admin/clipboard_controller.rb

@@ -8,6 +8,8 @@ module Alchemy
       authorize_resource class: :alchemy_admin_clipboard
       before_action :set_clipboard
 
+      helper_method :remarkable_type
+
       def index
         @clipboard_items = model_class.all_from_clipboard(@clipboard)
         respond_to do |format|
@@ -23,17 +25,11 @@ module Alchemy
             "action" => params[:remove] ? "cut" : "copy"
           }
         end
-        respond_to do |format|
-          format.js
-        end
       end
 
       def remove
         @item = model_class.find(remarkable_params[:remarkable_id])
         @clipboard.delete_if { |item| item["id"] == remarkable_params[:remarkable_id] }
-        respond_to do |format|
-          format.js
-        end
       end
 
       def clear

data/app/controllers/alchemy/admin/elements_controller.rb

@@ -35,7 +35,7 @@ module Alchemy
           else
             Element.new(create_element_params)
           end
-          if @page.definition["insert_elements_at"] == "top"
+          if @page.definition.insert_elements_at == "top"
             @insert_at_top = true
             @element.position = 1
           end

data/app/controllers/alchemy/admin/languages_controller.rb

@@ -14,7 +14,7 @@ module Alchemy
       def new
         @language = Language.new(
           site: @current_site,
-          page_layout: Config.get(:default_language)["page_layout"]
+          page_layout: Alchemy.config.default_language.page_layout
         )
       end
 

data/app/controllers/alchemy/admin/pages_controller.rb

@@ -37,6 +37,16 @@ module Alchemy
         if: :run_on_page_layout_callbacks?,
         only: [:show]
 
+      add_alchemy_filter :by_page_layout, type: :select, options: ->(_q) do
+        PageDefinition.all.map { |p| [Alchemy.t(p[:name], scope: "page_layout_names"), p[:name]] }
+      end
+
+      add_alchemy_filter :updated_at_gteq, type: :datepicker
+      add_alchemy_filter :updated_at_lteq, type: :datepicker
+      add_alchemy_filter :published, type: :checkbox
+      add_alchemy_filter :not_public, type: :checkbox
+      add_alchemy_filter :restricted, type: :checkbox
+
       def index
         @query = @current_language.pages.contentpages.ransack(search_filter_params[:q])
 
@@ -48,10 +58,6 @@ module Alchemy
             items = items.tagged_with(search_filter_params[:tagged_with])
           end
 
-          if search_filter_params[:filter].present?
-            items = apply_filters(items)
-          end
-
           items = items.page(params[:page] || 1).per(items_per_page)
           @pages = items
         end
@@ -69,7 +75,7 @@ module Alchemy
         Current.preview_page = @page
         # Setting the locale to pages language, so the page content has it's correct translations.
         ::I18n.locale = @page.language.locale
-        render(layout: Alchemy::Config.get(:admin_page_preview_layout) || "application")
+        render(layout: Alchemy.config.admin_page_preview_layout || "application")
       end
 
       def info
@@ -155,16 +161,10 @@ module Alchemy
           flash[:warning] = @page.errors.full_messages.to_sentence
         end
 
-        respond_to do |format|
-          format.js do
-            @redirect_url = if @page.layoutpage?
-              alchemy.admin_layoutpages_path
-            else
-              alchemy.admin_pages_path
-            end
-
-            render :redirect
-          end
+        if @page.layoutpage?
+          redirect_to alchemy.admin_layoutpages_path
+        else
+          redirect_to alchemy.admin_pages_path
         end
       end
 

data/app/controllers/alchemy/admin/pictures_controller.rb

@@ -21,9 +21,17 @@ module Alchemy
         @picture = Picture.find(params[:id])
       end
 
+      add_alchemy_filter :by_file_format, type: :select, options: ->(query) do
+        Alchemy::Picture.file_formats(query.result)
+      end
+      add_alchemy_filter :recent, type: :checkbox
+      add_alchemy_filter :last_upload, type: :checkbox
+      add_alchemy_filter :without_tag, type: :checkbox
+      add_alchemy_filter :deletable, type: :checkbox
+
       def index
         @query = Picture.ransack(search_filter_params[:q])
-        @pictures = filtered_pictures.includes(:thumbs)
+        @pictures = Alchemy.storage_adapter.preloaded_pictures(filtered_pictures)
 
         if in_overlay?
           archive_overlay
@@ -139,10 +147,6 @@ module Alchemy
           pictures = pictures.tagged_with(params[:tagged_with])
         end
 
-        if search_filter_params[:filter].present?
-          pictures = apply_filters(pictures)
-        end
-
         pictures = pictures.page(params[:page] || 1).per(items_per_page)
 
         pictures.order(:name)

data/app/controllers/alchemy/admin/resources_controller.rb

@@ -1,21 +1,16 @@
 # frozen_string_literal: true
 
 require "csv"
-require "alchemy/resource"
-require "alchemy/resources_helper"
-require "alchemy/resource_filter"
 
 module Alchemy
   module Admin
     class ResourcesController < Alchemy::Admin::BaseController
-      COMMON_SEARCH_FILTER_EXCLUDES = %i[id utf8 _method _ format].freeze
-
       include Alchemy::ResourcesHelper
+      extend Alchemy::Admin::ResourceName
+      include Alchemy::Admin::ResourceFilter
 
       helper Alchemy::ResourcesHelper, TagsHelper
-      helper_method :resource_handler, :search_filter_params,
-        :items_per_page, :items_per_page_options, :resource_has_filters,
-        :resource_filters_for_select
+      helper_method :resource_handler, :items_per_page, :items_per_page_options
 
       before_action :load_resource,
         only: %i[show edit update destroy]
@@ -29,21 +24,20 @@ module Alchemy
 
         items = items.includes(*resource_relations_names) if contains_relations?
         items = items.tagged_with(search_filter_params[:tagged_with]) if search_filter_params[:tagged_with].present?
-        items = apply_filters(items) if search_filter_params[:filter].present?
 
         respond_to do |format|
           format.html do
             items = items.page(params[:page] || 1).per(items_per_page)
-            instance_variable_set(:"@#{resource_handler.resources_name}", items)
+            instance_variable_set(:"@#{resources_name}", items)
           end
           format.csv do
-            instance_variable_set(:"@#{resource_handler.resources_name}", items)
+            instance_variable_set(:"@#{resources_name}", items)
           end
         end
       end
 
       def new
-        instance_variable_set(:"@#{resource_handler.resource_name}", resource_handler.model.new)
+        instance_variable_set(:"@#{resource_name}", resource_handler.model.new)
       end
 
       def show
@@ -54,7 +48,7 @@ module Alchemy
       end
 
       def create
-        instance_variable_set(:"@#{resource_handler.resource_name}", resource_handler.model.new(resource_params))
+        instance_variable_set(:"@#{resource_name}", resource_handler.model.new(resource_params))
         resource_instance_variable.save
         render_errors_or_redirect(
           resource_instance_variable,
@@ -85,62 +79,8 @@ module Alchemy
         @_resource_handler ||= Alchemy::Resource.new(controller_path, alchemy_module)
       end
 
-      def resource_has_filters
-        resource_model.respond_to?(:alchemy_resource_filters)
-      end
-
-      def resource_has_deprecated_filters
-        resource_model.alchemy_resource_filters.any? { |f| !f.is_a?(Hash) }
-      end
-
-      def resource_filters
-        return unless resource_has_filters
-
-        @_resource_filters ||= resource_model.alchemy_resource_filters
-      end
-
-      def resource_filters_for_select
-        resource_filters.map do |filter|
-          ResourceFilter.new(filter, resource_handler.resource_name)
-        end
-      end
-
       protected
 
-      def apply_filters(items)
-        sanitize_filter_params!
-
-        search_filter_params[:filter].each do |filter|
-          if argument_scope_filter?(filter)
-            items = items.public_send(filter[0], filter[1])
-          elsif simple_scope_filter?(filter)
-            items = items.public_send(filter[1])
-          else
-            raise "Can't apply filter #{filter[0]}. Either the name or the values must be defined as class methods / scopes on the model."
-          end
-        end
-
-        items
-      end
-
-      def simple_scope_filter?(filter)
-        resource_model.respond_to?(filter[1])
-      end
-
-      def argument_scope_filter?(filter)
-        resource_model.respond_to?(filter[0])
-      end
-
-      def sanitize_filter_params!
-        search_filter_params[:filter].reject! do |_, v|
-          eligible_resource_filter_values.exclude?(v)
-        end
-      end
-
-      def eligible_resource_filter_values
-        resource_filters.map(&:values).flatten!.map!(&:to_s)
-      end
-
       # Returns a translated +flash[:notice]+ for current controller action.
       def flash_notice_for_resource_action(action = action_name)
         return if resource_instance_variable.errors.any?
@@ -174,61 +114,31 @@ module Alchemy
       end
 
       def load_resource
-        instance_variable_set(:"@#{resource_handler.resource_name}", resource_handler.model.find(params[:id]))
+        instance_variable_set(:"@#{resource_name}", resource_handler.model.find(params[:id]))
       end
 
       def authorize_resource
         authorize!(action_name.to_sym, resource_instance_variable || resource_handler.model)
       end
 
-      # Permits all parameters as default!
-      #
-      # THIS IS INSECURE! Although only signed in admin users can send requests anyway, but we should change this.
+      # Permits all editable resource attributes as default.
       #
-      # Please define this method in your inheriting controller and set the parameters you want to permit.
-      #
-      # TODO: Hook this into authorization provider.
+      # Define this method in your inheriting controller if you want to permit additional attributes.
       #
+      # @see Alchemy::Resource#editable_attributes
       def resource_params
-        params.require(resource_handler.namespaced_resource_name).permit!
-      end
-
-      def search_filter_params
-        @_search_filter_params ||= params.except(*COMMON_SEARCH_FILTER_EXCLUDES).permit(*common_search_filter_includes).to_h
-      end
-
-      def common_search_filter_includes
-        search_filters = [
-          {
-            q: [:s] + permitted_ransack_search_fields
-          },
-          :tagged_with,
-          :page,
-          :per_page
-        ]
-
-        if resource_has_filters
-          search_filters << {
-            filter: resource_filters.map { |f| f[:name] }
-          }
-        end
-
-        search_filters
-      end
-
-      def permitted_ransack_search_fields
-        [
-          resource_handler.search_field_name
-        ]
+        params.require(resource_handler.namespaced_resource_name).permit(
+          resource_handler.editable_attributes.map { _1[:name] }
+        )
       end
 
       def items_per_page
         cookies[:alchemy_items_per_page] =
-          params[:per_page] || cookies[:alchemy_items_per_page] || Alchemy::Config.get(:items_per_page)
+          params[:per_page] || cookies[:alchemy_items_per_page] || Alchemy.config.items_per_page
       end
 
       def items_per_page_options
-        per_page = Alchemy::Config.get(:items_per_page)
+        per_page = Alchemy.config.items_per_page
         [per_page, per_page * 2, per_page * 4]
       end
 

data/app/controllers/alchemy/attachments_controller.rb

@@ -2,37 +2,66 @@
 
 module Alchemy
   class AttachmentsController < BaseController
+    if Alchemy.storage_adapter.active_storage?
+      include ActiveStorage::Streaming
+    end
+
     before_action :load_attachment
     authorize_resource class: Alchemy::Attachment
 
+    self.etag_with_template_digest = false
+
     # sends file inline. i.e. for viewing pdfs/movies in browser
     def show
-      response.headers["Content-Length"] = @attachment.file.size.to_s
-      send_file(
-        @attachment.file.path,
-        {
-          filename: @attachment.file_name,
-          type: @attachment.file_mime_type,
-          disposition: "inline"
-        }
-      )
+      if Alchemy.storage_adapter.dragonfly?
+        send_attachment_file(disposition: :inline)
+      else
+        send_attachment_blob(disposition: :inline)
+      end
     end
 
     # sends file as attachment. aka download
     def download
+      if Alchemy.storage_adapter.dragonfly?
+        send_attachment_file(disposition: :attachment)
+      else
+        send_attachment_blob(disposition: :attachment)
+      end
+    end
+
+    private
+
+    def load_attachment
+      @attachment = Attachment.find(params[:id])
+    end
+
+    def send_attachment_file(disposition: :inline)
       response.headers["Content-Length"] = @attachment.file.size.to_s
+
       send_file(
-        @attachment.file.path, {
+        @attachment.file.path,
+        {
           filename: @attachment.file_name,
-          type: @attachment.file_mime_type
+          type: @attachment.file_mime_type,
+          disposition: disposition
         }
       )
     end
 
-    private
+    def send_attachment_blob(disposition: :inline)
+      @blob = @attachment.file.blob
 
-    def load_attachment
-      @attachment = Attachment.find(params[:id])
+      if request.headers["Range"].present?
+        send_blob_byte_range_data @blob, request.headers["Range"], disposition: disposition
+      else
+        http_cache_forever public: true do
+          response.headers["Accept-Ranges"] = "bytes"
+          send_blob_stream @blob, disposition: disposition
+          # Rails ActionController::Live removes the Content-Length header,
+          # but browsers need that to be able to show a progress bar during download.
+          response.headers["Content-Length"] = @blob.byte_size.to_s
+        end
+      end
     end
   end
 end

data/app/controllers/alchemy/messages_controller.rb

@@ -74,7 +74,7 @@ module Alchemy
     private
 
     def mailer_config
-      Alchemy::Config.get(:mailer)
+      Alchemy.config.mailer
     end
 
     def mail_to

data/app/controllers/alchemy/pages_controller.rb

@@ -106,7 +106,12 @@ module Alchemy
     def load_index_page
       @page ||= Language.current_root_page
       Current.page = @page
-      render template: "alchemy/welcome", layout: false if signup_required?
+
+      if signup_required? && @page.nil?
+        render template: "alchemy/welcome", layout: false
+      elsif !@page&.public?
+        render template: "alchemy/no_index", layout: false
+      end
     end
 
     # == Loads page by urlname
@@ -192,7 +197,7 @@ module Alchemy
 
     def signup_required?
       if Alchemy.user_class.respond_to?(:admins)
-        Alchemy.user_class.admins.empty? && @page.nil?
+        Alchemy.user_class.admins.empty?
       end
     end
 

data/app/controllers/concerns/alchemy/admin/resource_filter.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    module ResourceFilter
+      extend ActiveSupport::Concern
+      COMMON_SEARCH_FILTER_EXCLUDES = %i[id utf8 _method _ format].freeze
+
+      included do
+        prepend_before_action :initialize_alchemy_filters
+        helper_method :alchemy_filters, :search_form_name, :applied_filters, :search_filter_params, :resource_has_filters
+      end
+
+      class_methods do
+        # Adds a filter to the resource.
+        # @param name [String, Symbol] The name of the filter.
+        # @param type [Symbol] The type of the filter. Can currently be `:select` or `:checkbox`.
+        # @param args [Hash] Additional arguments for the filter.
+        # @example
+        #   add_alchemy_filter :by_location, type: :select, options: ->(query) { Location.pluck(:name, :id) }
+        #   add_alchemy_filter :future, type: :checkbox
+        #   add_alchemy_filter :by_timeframe, type: :select, options: ["today", "tomorrow"]
+        def add_alchemy_filter(name, type:, **args)
+          alchemy_filters << "Alchemy::Admin::Filters::#{type.to_s.camelize}".constantize.new(
+            name:,
+            resource_name:,
+            **args
+          )
+        end
+
+        def alchemy_filters
+          @alchemy_filters ||= []
+        end
+      end
+      delegate :alchemy_filters, to: :class
+
+      private
+
+      def initialize_alchemy_filters
+        return if alchemy_filters.any?
+        return unless resource_model.respond_to?(:alchemy_resource_filters)
+        Alchemy::Deprecation.warn(
+          "The `alchemy_resource_filters` method is deprecated and will be removed in Alchemy 8.1. " \
+          "Please use `add_alchemy_filter` in your controller instead. Make sure to safelist the scopes " \
+          "you want to use in the `ransackable_scopes` method of your model."
+        )
+        resource_model.alchemy_resource_filters.each do |filter_config|
+          if resource_model.respond_to?(filter_config[:name])
+            self.class.add_alchemy_filter filter_config[:name], type: :select, options: filter_config[:values]
+          else
+            filter_config[:values].each do |scope|
+              self.class.add_alchemy_filter scope, type: :checkbox
+            end
+          end
+        end
+      end
+
+      def search_filter_params
+        @_search_filter_params ||= params.except(*COMMON_SEARCH_FILTER_EXCLUDES).permit(*common_search_filter_includes).to_h
+      end
+
+      def common_search_filter_includes
+        [
+          {
+            q: [:s] + permitted_ransack_search_fields
+          },
+          :tagged_with,
+          :page,
+          :per_page
+        ]
+      end
+
+      def permitted_ransack_search_fields
+        [
+          resource_handler.search_field_name
+        ] + alchemy_filters.map(&:name)
+      end
+
+      def resource_has_filters
+        alchemy_filters.any?
+      end
+
+      def applied_filters
+        return [] unless search_filter_params[:q]
+
+        alchemy_filters.select do |alchemy_filter|
+          search_filter_params[:q][alchemy_filter.name].present?
+        end
+      end
+    end
+  end
+end