alchemy_cms 7.4.10 → 8.0.0.b

data/app/javascript/alchemy_admin/utils/ajax.js

@@ -1,27 +1,37 @@
-function buildPromise(xhr) {
-  return new Promise((resolve, reject) => {
-    xhr.onload = () => {
-      if (xhr.status >= 200 && xhr.status < 400) {
-        try {
-          resolve({
-            data: JSON.parse(xhr.responseText),
-            status: xhr.status
-          })
-        } catch (error) {
-          reject(error)
-        }
-      } else {
-        try {
-          reject(JSON.parse(xhr.responseText))
-        } catch (error) {
-          reject(error)
-        }
-      }
-    }
-    xhr.onerror = () => {
-      reject(new Error("An error occurred during the transaction"))
-    }
-  })
+const JSON_CONTENT_TYPE = "application/json"
+
+function isGetRequest(method) {
+  return method.toLowerCase() === "get"
+}
+
+function prepareURL(path, data, method) {
+  const url = new URL(window.location.origin + path)
+
+  if (data && isGetRequest(method)) {
+    url.search = new URLSearchParams(data).toString()
+  }
+
+  return url.toString()
+}
+
+function prepareHeaders(accept) {
+  return {
+    "Content-Type": "application/json; charset=utf-8",
+    Accept: accept,
+    "X-Requested-With": "XMLHttpRequest",
+    "X-CSRF-Token": getToken()
+  }
+}
+
+function prepareOptions(method, data, accept) {
+  const headers = prepareHeaders(accept)
+  const options = { method, headers }
+
+  if (data && !isGetRequest(method)) {
+    options.body = JSON.stringify(data)
+  }
+
+  return options
 }
 
 export function getToken() {
@@ -37,30 +47,27 @@ export function patch(url, data) {
   return ajax("PATCH", url, data)
 }
 
-export function post(url, data, accept = "application/json") {
+export function post(url, data, accept = JSON_CONTENT_TYPE) {
   return ajax("POST", url, data, accept)
 }
 
-export default function ajax(method, path, data, accept = "application/json") {
-  const xhr = new XMLHttpRequest()
-  const promise = buildPromise(xhr)
-  const url = new URL(window.location.origin + path)
+export default async function ajax(
+  method,
+  path,
+  data,
+  accept = JSON_CONTENT_TYPE
+) {
+  const response = await fetch(
+    prepareURL(path, data, method),
+    prepareOptions(method, data, accept)
+  )
+  const contentType = response.headers.get("content-type")
+  const isJson = contentType?.includes(JSON_CONTENT_TYPE)
+  const responseData = isJson ? await response.json() : null
 
-  if (data && method.toLowerCase() === "get") {
-    url.search = new URLSearchParams(data).toString()
-  }
-
-  xhr.open(method, url.toString())
-  xhr.setRequestHeader("Content-type", "application/json; charset=utf-8")
-  xhr.setRequestHeader("Accept", accept)
-  xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest")
-  xhr.setRequestHeader("X-CSRF-Token", getToken())
-
-  if (data && method.toLowerCase() !== "get") {
-    xhr.send(JSON.stringify(data))
+  if (response.ok) {
+    return { data: responseData, status: response.status }
   } else {
-    xhr.send()
+    throw responseData || new Error("An error occurred during the transaction")
   }
-
-  return promise
 }

data/app/javascript/alchemy_admin.js

@@ -20,10 +20,7 @@ import Sitemap from "alchemy_admin/sitemap"
 import Spinner from "alchemy_admin/spinner"
 import PagePublicationFields from "alchemy_admin/page_publication_fields"
 import { reloadPreview } from "alchemy_admin/components/preview_window"
-import {
-  openConfirmDialog,
-  confirmToDeleteDialog
-} from "alchemy_admin/confirm_dialog"
+import { openConfirmDialog } from "alchemy_admin/confirm_dialog"
 
 // Web Components
 import "alchemy_admin/components"
@@ -53,11 +50,9 @@ Object.assign(Alchemy, {
   Sitemap,
   Spinner,
   PagePublicationFields,
-  reloadPreview,
-  openConfirmDialog,
-  confirmToDeleteDialog
+  reloadPreview
 })
 
 Rails.start()
-
+Turbo.config.forms.confirm = openConfirmDialog
 $(document).on("turbo:load", Initializer)

data/app/jobs/alchemy/delete_picture_job.rb

@@ -0,0 +1,12 @@
+module Alchemy
+  class DeletePictureJob < BaseJob
+    queue_as :default
+
+    def perform(picture_id)
+      picture = Alchemy::Picture.find_by(id: picture_id)
+      return if picture.nil? || !picture.deletable?
+
+      picture.destroy
+    end
+  end
+end

data/app/models/alchemy/admin/filters/base.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    module Filters
+      class Base
+        attr_reader :name, :resource_name
+
+        def initialize(name:, resource_name:)
+          @name = name
+          @resource_name = resource_name
+        end
+
+        def applied_filter_component(search_filter_params:, resource_url_proxy:, query:)
+          Alchemy::Admin::Resource::AppliedFilter.new(
+            link: dismiss_filter_url(search_filter_params, resource_url_proxy),
+            applied_filter_label: translated_name,
+            applied_filter_value: translated_value(search_filter_params[:q][name], query)
+          )
+        end
+
+        private
+
+        def translated_name
+          Alchemy.t(:name, scope: [:filters, resource_name, name], default: name.to_s.humanize)
+        end
+
+        def dismiss_filter_url(search_filter_params, resource_url_proxy)
+          tmp_params = search_filter_params.dup
+          tmp_params[:q] = tmp_params[:q].except(name)
+          resource_url_proxy.url_for(
+            {action: "index"}.merge(tmp_params.except(:page))
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/alchemy/admin/filters/checkbox.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    module Filters
+      class Checkbox < Base
+        # Renders a checkbox filter input.
+        # @param [Hash] params The controller params.
+        # @param [Ransack::Search] _query The current search query.
+        # @return [Alchemy::Admin::FilterInputs::Checkbox] The checkbox filter input component.
+        def input_component(params, _query)
+          Alchemy::Admin::Resource::CheckboxFilter.new(name:, label: translated_name, params:)
+        end
+
+        def applied_filter_component(search_filter_params:, resource_url_proxy:, query:)
+          Alchemy::Admin::Resource::AppliedFilter.new(
+            link: dismiss_filter_url(search_filter_params, resource_url_proxy),
+            applied_filter_label: translated_name
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/alchemy/admin/filters/datepicker.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    module Filters
+      class Datepicker < Base
+        attr_reader :input_type
+        # Creates a resource filter that displays as a datepicker.
+        # @param name [String] The name of the filter.
+        # @param resource_name [String] The name of the resource.
+        # @param input_type [Symbol] The input type of the datepicker. Can be :date, :datetime, or :time.
+        # @example
+        #  Alchemy::Admin::Filters::Datepicker.new(
+        #  name: :created_at_lt,
+        #  resource_name: :events,
+        #  mode: :single,
+        #  default: "2023-01-01"
+        def initialize(name:, resource_name:, input_type: :datetime)
+          super(name:, resource_name:)
+          @input_type = input_type
+        end
+
+        # Returns a datepicker filter component.
+        # @param params [Hash] The search filter params.
+        # @param query [Ransack::Search] The current search query.
+        # @return [Alchemy::Admin::Resource::DatepickerFilter] The datepicker filter component.
+        def input_component(params, _query)
+          Alchemy::Admin::Resource::DatepickerFilter.new(
+            name:,
+            label: translated_name,
+            input_type: @input_type,
+            params:
+          )
+        end
+
+        private
+
+        def translated_value(value, query)
+          date = Time.zone.parse(value) if value.is_a?(String)
+          format = case input_type
+          when :date
+            ::I18n.t(:default, scope: [:date, :formats, :alchemy])
+          when :datetime
+            ::I18n.t(:default, scope: [:time, :formats, :alchemy])
+          when :time
+            ::I18n.t(:time, scope: [:time, :formats, :alchemy])
+          end
+          ::I18n.l(date, format: format)
+        end
+      end
+    end
+  end
+end

data/app/models/alchemy/admin/filters/select.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    module Filters
+      class Select < Base
+        attr_reader :options
+
+        # Creates a resource filter that displays as a select.
+        # @param name [String] The name of the filter.
+        # @param resource_name [String] The name of the resource.
+        # @param options [Proc, Array] A proc that returns the options for the select, or an array of options.
+        def initialize(name:, resource_name:, options:)
+          super(name:, resource_name:)
+          @options = options_to_proc(options)
+        end
+
+        # Returns a select filter component.
+        # @param params [Hash] The search filter params.
+        # @param query [Ransack::Search] The current search query.
+        # @return [ Alchemy::Admin::Resource::SelectFilter] The select filter component.
+        def input_component(params, query)
+          Alchemy::Admin::Resource::SelectFilter.new(
+            name:,
+            resource_name:,
+            label: translated_name,
+            include_blank:,
+            options: get_options_for_select(query),
+            params:
+          )
+        end
+
+        private
+
+        def include_blank
+          Alchemy.t(:all, scope: [:filters, resource_name, name])
+        end
+
+        def options_to_proc(options)
+          if options.is_a? Proc
+            options
+          else
+            ->(_query) { options }
+          end
+        end
+
+        def get_options_for_select(query)
+          options_for_select = options.call(query)
+          # The result of the query is an Array of Arrays, where the first element is the translated name and the second element is the value.
+          # If the first element is an Array, we assume that the options are already translated.
+          if options_for_select.first.is_a? Array
+            options_for_select
+          # If the values are translatable, we translate them.
+          elsif Alchemy.t(:values, scope: [:filters, resource_name, name])
+            options_for_select.map do |value|
+              [Alchemy.t(value.to_sym, scope: [:filters, resource_name, name, :values]), value]
+            end
+          # Otherwise we return the options as they are.
+          else
+            options_for_select.map { |option| [option, option] }
+          end
+        end
+
+        def translated_value(value, query)
+          get_options_for_select(query).detect { |option| option[1].to_s == value }&.first
+        end
+      end
+    end
+  end
+end

data/app/models/alchemy/admin/resource_name.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    module ResourceName
+      def resource_model_name
+        resource_array.join("/").classify
+      end
+
+      def resource_name
+        resources_name.singularize
+      end
+
+      def resource_array
+        controller_path_array.reject { |el| el == "admin" }
+      end
+
+      def resources_name
+        resource_array.last
+      end
+
+      def controller_path_array
+        controller_path.split("/")
+      end
+    end
+  end
+end

data/app/models/alchemy/attachment.rb

@@ -23,22 +23,16 @@ module Alchemy
     include Alchemy::NameConversions
     include Alchemy::Taggable
     include Alchemy::TouchElements
+    include Alchemy::RelatableResource
 
-    dragonfly_accessor :file, app: :alchemy_attachments do
-      after_assign { |f| write_attribute(:file_mime_type, f.mime_type) }
-    end
-
-    stampable stamper_class_name: Alchemy.user_class.name
+    include Alchemy.storage_adapter.attachment_class_methods
 
-    has_many :file_ingredients,
-      class_name: "Alchemy::Ingredients::File",
-      foreign_key: "related_object_id",
-      inverse_of: :related_object
+    stampable stamper_class_name: Alchemy.user_class_name
 
-    has_many :elements, through: :file_ingredients
-    has_many :pages, through: :elements
+    scope :by_file_type, ->(file_type) do
+      Alchemy.storage_adapter.by_file_type_scope(file_type)
+    end
 
-    scope :by_file_type, ->(file_type) { where(file_mime_type: file_type) }
     scope :recent, -> { where("#{table_name}.created_at > ?", Time.current - 24.hours).order(:created_at) }
     scope :without_tag, -> { left_outer_joins(:taggings).where(gutentag_taggings: {id: nil}) }
 
@@ -46,9 +40,8 @@ module Alchemy
     class << self
       # The class used to generate URLs for attachments
       #
-      # @see Alchemy::Attachment::Url
       def url_class
-        @_url_class ||= Alchemy::Attachment::Url
+        @_url_class ||= Alchemy.storage_adapter.attachment_url_class
       end
 
       # Set a different attachment url class
@@ -58,19 +51,6 @@ module Alchemy
         @_url_class = klass
       end
 
-      def alchemy_resource_filters
-        [
-          {
-            name: :by_file_type,
-            values: distinct.pluck(:file_mime_type).map { |type| [Alchemy.t(type, scope: "mime_types"), type] }.sort_by(&:first)
-          },
-          {
-            name: :misc,
-            values: %w[recent last_upload without_tag]
-          }
-        ]
-      end
-
       def last_upload
         last_id = Attachment.maximum(:id)
         return Attachment.all unless last_id
@@ -79,34 +59,43 @@ module Alchemy
       end
 
       def searchable_alchemy_resource_attributes
-        %w[name file_name]
+        Alchemy.storage_adapter.searchable_alchemy_resource_attributes(name)
+      end
+
+      def ransackable_attributes(_auth_object = nil)
+        Alchemy.storage_adapter.ransackable_attributes(name)
+      end
+
+      def ransackable_associations(_auth_object = nil)
+        Alchemy.storage_adapter.ransackable_associations(name)
+      end
+
+      def file_types(scope = all)
+        Alchemy.storage_adapter.file_formats(name, scope:)
       end
 
       def allowed_filetypes
-        Config.get(:uploader).fetch("allowed_filetypes", {}).fetch("alchemy/attachments", [])
+        Alchemy.config.uploader.allowed_filetypes.alchemy_attachments
+      end
+
+      def ransackable_scopes(_auth_object = nil)
+        %i[by_file_type recent last_upload without_tag deletable]
       end
     end
 
     validates_presence_of :file
-    validates_size_of :file, maximum: Config.get(:uploader)["file_size_limit"].megabytes
-    validates_property :ext,
-      of: :file,
-      in: allowed_filetypes,
-      case_sensitive: false,
-      message: Alchemy.t("not a valid file"),
+    validates_size_of :file, maximum: Alchemy.config.uploader.file_size_limit.megabytes
+    validate :file_type_allowed,
       unless: -> { self.class.allowed_filetypes.include?("*") }
 
-    before_save :sanitize_file_name
-    before_save :set_name, if: :file_name_changed?
+    before_save :set_name, if: -> { Alchemy.storage_adapter.set_attachment_name?(self) }
 
     scope :with_file_type, ->(file_type) { where(file_mime_type: file_type) }
 
     # Instance methods
 
     def url(options = {})
-      if file
-        self.class.url_class.new(self).call(options)
-      end
+      self.class.url_class.new(self).call(options)
     end
 
     # An url save filename without format suffix
@@ -119,9 +108,23 @@ module Alchemy
       pages.any? && pages.not_restricted.blank?
     end
 
+    # File name
+    def file_name
+      Alchemy.storage_adapter.file_name(self)
+    end
+
+    # File size
+    def file_size
+      Alchemy.storage_adapter.file_size(self)
+    end
+
+    def file_mime_type
+      Alchemy.storage_adapter.file_mime_type(self)
+    end
+
     # File format suffix
     def extension
-      file_name.split(".").last
+      Alchemy.storage_adapter.file_extension(self)
     end
 
     alias_method :suffix, :extension
@@ -157,12 +160,14 @@ module Alchemy
 
     private
 
-    def sanitize_file_name
-      self.file_name = sanitized_filename(file_name)
+    def file_type_allowed
+      unless extension&.in?(self.class.allowed_filetypes)
+        errors.add(:file, Alchemy.t("not a valid file"))
+      end
     end
 
     def set_name
-      self.name = convert_to_humanized_name(file_name, file.ext)
+      self.name ||= convert_to_humanized_name(file_name, extension)
     end
   end
 end

data/app/models/alchemy/base_record.rb

@@ -6,6 +6,8 @@ module Alchemy
   end
 
   class BaseRecord < ActiveRecord::Base
+    include ConfigMissing
+    extend ConfigMissing
     extend Alchemy::SearchableResource
 
     self.abstract_class = true

data/app/models/alchemy/element/definitions.rb

@@ -46,7 +46,7 @@ module Alchemy
         else
           log_warning "Could not find element definition for #{name}. " \
                       "Please check your elements.yml file!"
-          {}
+          ElementDefinition.new
         end
       end
     end

data/app/models/alchemy/element/element_ingredients.rb

@@ -53,16 +53,16 @@ module Alchemy
 
       # Returns all element ingredient definitions from the +elements.yml+ file
       def ingredient_definitions
-        definition.fetch(:ingredients, [])
+        definition.ingredients
       end
 
       # Returns the definition for given ingredient role
       def ingredient_definition_for(role)
         if ingredient_definitions.blank?
-          log_warning "Element #{name} is missing the ingredient definition for #{role}"
           nil
         else
-          ingredient_definitions.find { |d| d[:role] == role.to_s }
+          ingredient_definitions.find { _1.role == role.to_s } ||
+            log_warning("Element #{name} is missing the ingredient definition for #{role}")
         end
       end
 
@@ -99,10 +99,10 @@ module Alchemy
 
       # Builds ingredients for this element as described in the +elements.yml+
       def build_ingredients
-        ingredient_definitions.each do |attributes|
+        ingredient_definitions.each do |definition|
           ingredients.build(
-            role: attributes[:role],
-            type: Alchemy::Ingredient.normalize_type(attributes[:type])
+            role: definition.role,
+            type: Alchemy::Ingredient.normalize_type(definition.type)
           )
         end
       end

data/app/models/alchemy/element/presenters.rb

@@ -33,7 +33,7 @@ module Alchemy
       # @see Alchemy::Element::Presenters#display_name_for
       #
       def display_name
-        self.class.display_name_for(definition["name"] || name)
+        self.class.display_name_for(definition.name || name)
       end
 
       # Returns a preview text for element.
@@ -78,15 +78,6 @@ module Alchemy
         "#{display_name}: #{preview_text(maxlength)}"
       end
 
-      # Returns a dom id used for elements html id tag.
-      # @deprecated
-      def dom_id
-        if caller.none? { |l| l =~ Regexp.new("alchemy/elements_block_helper.rb:117:in `element_view_for'") }
-          Alchemy::Deprecation.warn("dom_id is deprecated and will be removed from Alchemy 8.0. Please pass an id to the element_view_for helper instead.")
-        end
-        self.class.dom_id_class.new(self).call
-      end
-
       # The ingredient that's used for element's preview text.
       #
       # It tries to find one of element's ingredients that is defined +as_element_title+.
@@ -113,8 +104,8 @@ module Alchemy
       def first_ingredient_by_definition
         return if ingredient_definitions.empty?
 
-        role = ingredient_definitions.first["role"]
-        ingredients.detect { |ingredient| ingredient.role == role }
+        role = ingredient_definitions.first.role
+        ingredients.detect { _1.role == role }
       end
     end
   end