alchemy_cms 5.2.0 → 6.0.0.b3

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    class EssenceVideosController < Alchemy::Admin::BaseController
+      authorize_resource class: Alchemy::EssenceVideo
+      before_action :load_essence
+
+      def update
+        @essence_video.update(essence_video_params)
+      end
+
+      private
+
+      def load_essence
+        @essence_video = EssenceVideo.find(params[:id])
+      end
+
+      def essence_video_params
+        params.require(:essence_video).permit(
+          :width,
+          :height,
+          :autoplay,
+          :controls,
+          :loop,
+          :muted,
+          :preload,
+          :attachment_id
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    class IngredientsController < Alchemy::Admin::BaseController
+      load_and_authorize_resource class: Alchemy::Ingredient
+
+      include CropAction
+
+      helper "Alchemy::Admin::Ingredients"
+
+      def edit
+      end
+
+      def update
+        @ingredient.update(ingredient_params)
+      end
+
+      private
+
+      def ingredient_params
+        params.require(:ingredient).permit(@ingredient.class.stored_attributes[:data])
+      end
+
+      def load_croppable_resource
+        @croppable_resource = @ingredient
+      end
+    end
+  end
+end

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

@@ -16,7 +16,6 @@ module Alchemy
 
       def edit
         @page = Page.find(params[:id])
-        @page_layouts = PageLayout.layouts_with_own_for_select(@page.page_layout, @current_language.id, true)
       end
     end
   end

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

@@ -33,6 +33,8 @@ module Alchemy
 
       before_action :set_view, only: [:index]
 
+      before_action :set_page_version, only: [:show, :edit]
+
       def index
         @query = @current_language.pages.contentpages.ransack(search_filter_params[:q])
 
@@ -45,11 +47,7 @@ module Alchemy
           end
 
           if search_filter_params[:filter].present?
-            items = items.public_send(sanitized_filter_params)
-          end
-
-          if search_filter_params[:page_layout].present?
-            items = items.where(page_layout: search_filter_params[:page_layout])
+            items = apply_filters(items)
           end
 
           items = items.page(params[:page] || 1).per(items_per_page)
@@ -118,7 +116,6 @@ module Alchemy
 
       # Set page configuration like page names, meta tags and states.
       def configure
-        @page_layouts = PageLayout.layouts_with_own_for_select(@page.page_layout, @current_language.id, @page.layoutpage?)
       end
 
       # Updates page
@@ -191,24 +188,12 @@ module Alchemy
         end
       end
 
-      def visit
-        @page.unlock!
-        redirect_to show_page_url(
-          urlname: @page.urlname,
-          locale: prefix_locale? ? @page.language_code : nil,
-          host: @page.site.host == "*" ? request.host : @page.site.host,
-        )
-      end
-
       # Sets the page public and updates the published_at attribute that is used as cache_key
       #
       def publish
         # fetching page via before filter
         @page.publish!
 
-        # Send publish notification to all registered publish targets
-        Alchemy.publish_targets.each { |p| p.perform_later(@page) }
-
         flash[:notice] = Alchemy.t(:page_published, name: @page.name)
         redirect_back(fallback_location: admin_pages_path)
       end
@@ -255,10 +240,6 @@ module Alchemy
         @_resource_handler ||= Alchemy::Resource.new(controller_path, alchemy_module, Alchemy::Page)
       end
 
-      def common_search_filter_includes
-        super.push(:page_layout, :view)
-      end
-
       def set_view
         @view = params[:view] || session[:alchemy_pages_view] || "tree"
         session[:alchemy_pages_view] = @view
@@ -403,6 +384,10 @@ module Alchemy
         @page_root = @current_language.root_page
       end
 
+      def set_page_version
+        @page_version = @page.draft_version
+      end
+
       def serialized_page_tree
         PageTreeSerializer.new(@page, ability: current_ability,
                                       user: current_alchemy_user,

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

@@ -9,20 +9,19 @@ module Alchemy
       helper "alchemy/admin/tags"
 
       before_action :load_resource,
-        only: [:show, :edit, :update, :destroy, :info]
+        only: [:show, :edit, :update, :url, :destroy, :info]
 
       before_action :set_size, only: [:index, :show, :edit_multiple]
 
       authorize_resource class: Alchemy::Picture
 
+      before_action(only: :assign) do
+        @picture = Picture.find(params[:id])
+      end
+
       def index
         @query = Picture.ransack(search_filter_params[:q])
-        @pictures = Picture.search_by(
-          search_filter_params,
-          @query,
-          items_per_page,
-        )
-        @pictures = @pictures.includes(:thumbs)
+        @pictures = filtered_pictures.includes(:thumbs)
 
         if in_overlay?
           archive_overlay
@@ -30,12 +29,25 @@ module Alchemy
       end
 
       def show
-        @previous = @picture.previous(params)
-        @next = @picture.next(params)
-        @assignments = @picture.essence_pictures.joins(content: {element: :page})
+        @query = Picture.ransack(params[:q])
+        @previous = filtered_pictures.where("name < ?", @picture.name).last
+        @next = filtered_pictures.where("name > ?", @picture.name).first
+        @assignments = @picture.essence_pictures.joins(content: { element: :page })
+
         render action: "show"
       end
 
+      def url
+        options = picture_url_params.to_h.symbolize_keys.transform_values! do |value|
+          value.in?(%w[true false]) ? value == "true" : value
+        end
+        render json: {
+          url: @picture.url(options),
+          alt: @picture.name,
+          title: Alchemy.t(:image_name, name: @picture.name),
+        }
+      end
+
       def create
         @picture = Picture.new(picture_params)
         @picture.name = @picture.humanized_name
@@ -115,6 +127,22 @@ module Alchemy
         redirect_to_index
       end
 
+      def filtered_pictures
+        pictures = @query.result
+
+        if params[:tagged_with].present?
+          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)
+      end
+
       def items_per_page
         if in_overlay?
           case @size
@@ -125,8 +153,8 @@ module Alchemy
           end
         else
           cookies[:alchemy_pictures_per_page] = params[:per_page] ||
-            cookies[:alchemy_pictures_per_page] ||
-            pictures_per_page_for_size
+                                                cookies[:alchemy_pictures_per_page] ||
+                                                pictures_per_page_for_size
         end
       end
 
@@ -158,17 +186,28 @@ module Alchemy
       def search_filter_params
         @_search_filter_params ||= params.except(*COMMON_SEARCH_FILTER_EXCLUDES + [:picture_ids]).permit(
           *common_search_filter_includes + [
-            :size,
-            :element_id,
-            :swap,
-            :content_id,
-          ],
+          :size,
+          :form_field_id,
+        ],
         )
       end
 
       def picture_params
         params.require(:picture).permit(:image_file, :upload_hash, :name, :tag_list)
       end
+
+      def picture_url_params
+        params.permit(
+          :crop_from,
+          :crop_size,
+          :crop,
+          :flatten,
+          :format,
+          :quality,
+          :size,
+          :upsample
+        )
+      end
     end
   end
 end

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

@@ -3,6 +3,7 @@
 require "csv"
 require "alchemy/resource"
 require "alchemy/resources_helper"
+require "alchemy/resource_filter"
 
 module Alchemy
   module Admin
@@ -13,7 +14,8 @@ module Alchemy
 
       helper Alchemy::ResourcesHelper, TagsHelper
       helper_method :resource_handler, :search_filter_params,
-        :items_per_page, :items_per_page_options
+        :items_per_page, :items_per_page_options, :resource_has_filters,
+        :resource_filters_for_select
 
       before_action :load_resource,
         only: [:show, :edit, :update, :destroy]
@@ -34,7 +36,7 @@ module Alchemy
         end
 
         if search_filter_params[:filter].present?
-          items = items.public_send(sanitized_filter_params)
+          items = apply_filters(items)
         end
 
         respond_to do |format|
@@ -90,8 +92,79 @@ 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 ||= deprecated_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 deprecated_resource_filters
+        if resource_has_deprecated_filters
+          Alchemy::Deprecation.warn(
+            "#{resource_model}.alchemy_resource_filters is using a legacy data structure. " \
+            "Please use an Array of Hashes instead. i.e. [{ name: 'foo', values: ['bar', 'baz'] }, ...] " \
+            "where values are scopes. With Alchemy 6.1 only the new structure will be supported."
+          )
+
+          @_resource_filters ||= [
+            {
+              name: :misc,
+              values: resource_model.alchemy_resource_filters,
+            },
+          ]
+        end
+      end
+
+      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
+      end
+
       # Returns a translated +flash[:notice]+.
       # The key should look like "Modelname successfully created|updated|destroyed."
       def flash_notice_for_resource_action(action = params[:action])
@@ -136,27 +209,28 @@ module Alchemy
         params.require(resource_handler.namespaced_resource_name).permit!
       end
 
-      def sanitized_filter_params
-        resource_model.alchemy_resource_filters.detect do |filter|
-          filter == search_filter_params[:filter]
-        end || :all
-      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: [
             resource_handler.search_field_name,
             :s,
           ] },
           :tagged_with,
-          :filter,
           :page,
           :per_page,
         ]
+
+        if resource_has_filters
+          search_filters << {
+            filter: resource_filters.map { |f| f[:name] },
+          }
+        end
+
+        search_filters
       end
 
       def items_per_page

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

@@ -9,18 +9,25 @@ module Alchemy
     # If you want to only load a specific type of element pass ?named=an_element_name
     #
     def index
-      @elements = Element.not_nested
       # Fix for cancancan not able to merge multiple AR scopes for logged in users
       if cannot? :manage, Alchemy::Element
-        @elements = @elements.accessible_by(current_ability, :index)
+        @elements = Alchemy::Element.accessible_by(current_ability, :index)
+      else
+        @elements = Alchemy::Element.all
       end
+
+      @elements = @elements.not_nested.joins(:page_version).merge(PageVersion.published)
+
       if params[:page_id].present?
-        @elements = @elements.where(page_id: params[:page_id])
+        @elements = @elements.includes(:page).where(alchemy_pages: { id: params[:page_id] })
+      else
+        @elements = @elements.includes(*element_includes)
       end
+
       if params[:named].present?
         @elements = @elements.named(params[:named])
       end
-      @elements = @elements.includes(*element_includes)
+      @elements = @elements.order(:position)
 
       render json: @elements, adapter: :json, root: "elements"
     end
@@ -43,6 +50,7 @@ module Alchemy
               contents: {
                 essence: :ingredient_association,
               },
+              ingredients: :related_object,
             },
             :tags,
           ],
@@ -51,6 +59,7 @@ module Alchemy
           contents: {
             essence: :ingredient_association,
           },
+          ingredients: :related_object,
         },
         :tags,
       ]