alchemy_cms 7.4.10 → 8.0.0.b

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
@@ -186,13 +191,25 @@ module Alchemy
       if must_not_cache?
         expires_now
       else
-        expires_in @page.expiration_time, public: !@page.restricted, must_revalidate: true
+        expires_in @page.expiration_time, {public: !@page.restricted}.merge(caching_options)
+      end
+    end
+
+    def caching_options
+      if Alchemy.config.page_cache.stale_while_revalidate
+        {
+          stale_while_revalidate: Alchemy.config.page_cache.stale_while_revalidate
+        }
+      else
+        {
+          must_revalidate: true
+        }
       end
     end
 
     def signup_required?
       if Alchemy.user_class.respond_to?(:admins)
-        Alchemy.user_class.admins.empty? && @page.nil?
+        Alchemy.user_class.admins.empty?
       end
     end
 
@@ -224,7 +241,12 @@ module Alchemy
 
     # don't cache pages if we have flash message to display or the page has caching disabled
     def must_not_cache?
-      flash.present? || !@page.cache_page?
+      !caching_enabled? || !@page.cache_page? || flash.present?
+    end
+
+    def caching_enabled?
+      Rails.application.config.action_controller.perform_caching &&
+        Alchemy.config.cache_pages
     end
 
     def page_not_found!

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

@@ -0,0 +1,93 @@
+# 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

data/app/decorators/alchemy/element_editor.rb

@@ -14,7 +14,7 @@ module Alchemy
     #
     # @return Array<Alchemy::IngredientEditor>
     def ingredients
-      element.definition.fetch(:ingredients, []).map do |ingredient|
+      ingredient_definitions.map do |ingredient|
         Alchemy::IngredientEditor.new(find_or_create_ingredient(ingredient))
       end
     end
@@ -22,7 +22,7 @@ module Alchemy
     # Are any ingredients defined?
     # @return [Boolean]
     def has_ingredients_defined?
-      element.definition.fetch(:ingredients, []).any?
+      ingredient_definitions.any?
     end
 
     # Returns the translated ingredient group for displaying in admin editor group headings
@@ -77,56 +77,13 @@ module Alchemy
       super
     end
 
-    # Returns a deprecation notice for elements marked deprecated
-    #
-    # You can either use localizations or pass a String as notice
-    # in the element definition.
-    #
-    # == Custom deprecation notices
-    #
-    # Use general element deprecation notice
-    #
-    #     - name: old_element
-    #       deprecated: true
-    #
-    # Add a translation to your locale file for a per element notice.
-    #
-    #     en:
-    #       alchemy:
-    #         element_deprecation_notices:
-    #           old_element: Foo baz widget is deprecated
-    #
-    # or use the global translation that apply to all deprecated elements.
-    #
-    #     en:
-    #       alchemy:
-    #         element_deprecation_notice: Foo baz widget is deprecated
-    #
-    # or pass string as deprecation notice.
-    #
-    #     - name: old_element
-    #       deprecated: This element will be removed soon.
-    #
-    def deprecation_notice
-      case definition["deprecated"]
-      when String
-        definition["deprecated"]
-      when TrueClass
-        Alchemy.t(
-          name,
-          scope: :element_deprecation_notices,
-          default: Alchemy.t(:element_deprecated)
-        )
-      end
-    end
-
     private
 
     def find_or_create_ingredient(definition)
-      element.ingredients.detect { |i| i.role == definition[:role] } ||
+      element.ingredients.detect { _1.role == definition.role } ||
         element.ingredients.create!(
-          role: definition[:role],
-          type: Alchemy::Ingredient.normalize_type(definition[:type])
+          role: definition.role,
+          type: Alchemy::Ingredient.normalize_type(definition.type)
         )
     end
   end

data/app/decorators/alchemy/ingredient_editor.rb

@@ -99,62 +99,12 @@ module Alchemy
         Logger.warn("ingredient #{role} is missing its definition", caller(1..1))
         Alchemy.t(:ingredient_definition_missing)
       else
-        deprecation_notice
-      end
-    end
-
-    # Returns a deprecation notice for ingredients marked deprecated
-    #
-    # You can either use localizations or pass a String as notice
-    # in the ingredient definition.
-    #
-    # == Custom deprecation notices
-    #
-    # Use general ingredient deprecation notice
-    #
-    #     - name: element_name
-    #       ingredients:
-    #         - role: old_ingredient
-    #           type: Text
-    #           deprecated: true
-    #
-    # Add a translation to your locale file for a per ingredient notice.
-    #
-    #     en:
-    #       alchemy:
-    #         ingredient_deprecation_notices:
-    #           element_name:
-    #             old_ingredient: Foo baz widget is deprecated
-    #
-    # or use the global translation that apply to all deprecated ingredients.
-    #
-    #     en:
-    #       alchemy:
-    #         ingredient_deprecation_notice: Foo baz widget is deprecated
-    #
-    # or pass string as deprecation notice.
-    #
-    #     - name: element_name
-    #       ingredients:
-    #         - role: old_ingredient
-    #           type: Text
-    #           deprecated: This ingredient will be removed soon.
-    #
-    def deprecation_notice
-      case definition[:deprecated]
-      when String
-        definition[:deprecated]
-      when TrueClass
-        Alchemy.t(
-          role,
-          scope: [:ingredient_deprecation_notices, element.name],
-          default: Alchemy.t(:ingredient_deprecated)
-        )
+        definition.deprecation_notice(element_name: element&.name)
       end
     end
 
     def validations
-      definition.fetch(:validate, [])
+      definition.validate
     end
 
     def format_validation
@@ -173,7 +123,7 @@ module Alchemy
     private
 
     def form_field_counter
-      element.definition.fetch(:ingredients, []).index { |i| i[:role] == role }
+      element.ingredient_definitions.index { _1.role == role }
     end
   end
 end

data/app/helpers/alchemy/admin/attachments_helper.rb

@@ -12,12 +12,12 @@ module Alchemy
 
       def attachment_preview_size(attachment)
         case attachment.file_mime_type
-        when *IMAGE_FILE_TYPES then "600x475"
-        when *AUDIO_FILE_TYPES then "600x190"
-        when *VIDEO_FILE_TYPES then "600x485"
-        when "application/pdf" then "600x600"
+        when "application/pdf" then "850x600"
+        when *IMAGE_FILE_TYPES then "850x280"
+        when *AUDIO_FILE_TYPES then "850x190"
+        when *VIDEO_FILE_TYPES then "900x280"
         else
-          "600x145"
+          "500x165"
         end
       end
     end